prefix
stringlengths 82
32.6k
| middle
stringlengths 5
470
| suffix
stringlengths 0
81.2k
| file_path
stringlengths 6
168
| repo_name
stringlengths 16
77
| context
listlengths 5
5
| lang
stringclasses 4
values | ground_truth
stringlengths 5
470
|
|---|---|---|---|---|---|---|---|
# Copyright 2023 Eurobios
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.#
from typing import Type, Iterable
import pandas as pd
from acrocord import ConnectDatabase
from acrocord.utils.types import EligibleDataType
def not_nullable(data: pd.DataFrame, columns: Iterable[str]):
""" Function that verify if a column does not contains null values """
for column in columns:
assert not data[column].isnull().values.any(), f"Column" \
f" {column} " \
f"contains null values"
def data_type(data: pd.DataFrame, columns: Iterable[str],
dtype: Type):
""" Function that verify if the type of column is correct """
for column in columns:
assert data[column].dtype == dtype, \
f"Column {column} is {data[column].dtype}"
def eligible_data_type(data: pd.DataFrame):
result = data.dtypes
for column, type_ in result.items():
msg = f'The type of the column {column} is {type_} ' \
f'which is not an eligible type.'
assert type_ in EligibleDataType. | get_list(), msg |
def quantile(data: pd.DataFrame, columns: Iterable[str], q, threshold):
""" Function that verifies the quantile according to a threshold """
for column in columns:
assert data[column].quantile(q) < threshold
def unique(data: pd.DataFrame, columns: Iterable[str]):
""" Function that checks if the values of a column is unique """
for column in columns:
assert data[
column].nunique() == data.__len__(), f"Column {column} is not unique"
def nb_unique_index(data: pd.DataFrame, columns: Iterable[str], minimum,
maximum):
""" Function that checks if the number of unique objects is included in a given interval """
for column in columns:
msg = f"Column {column} est compris dans l'intervalle "
assert (data[column].nunique() < maximum) and (
data[column].nunique() >= minimum), msg
class DataConstraints:
def __init__(self, data: pd.DataFrame = None,
connection: ConnectDatabase = None):
self.data = data.copy()
self.constraints = {}
def add_constraint(self, constraint: dict):
self.constraints = {**self.constraints, **constraint}
def test(self):
for name in self.constraints.keys():
function, args = self.constraints[name]
args["data"] = self.data
function(**args)
| acrocord/test/constraints.py | eurobios-scb-acrocord-94aeb5e | [
{
"filename": "acrocord/utils/types.py",
"retrieved_chunk": "def warning_type(dataframe: pd.DataFrame, verbose: int):\n for column, column_type in dataframe.dtypes.items():\n if verbose == 2:\n if str(column_type) not in EligibleDataType.get_list():\n return warnings.warn(\n \"The types of this dataframe are not eligible types\")\n if verbose > 2:\n if str(column_type) not in EligibleDataType.get_list():\n msg = f\"The type of the column {column} \" \\\n f\"is {column_type} which is not an eligible type.\"",
"score": 79.93873669823478
},
{
"filename": "acrocord/utils/auxiliaries.py",
"retrieved_chunk": " SQL Query\n \"\"\"\n sql_cmd = f\"SELECT * FROM information_schema.tables \" \\\n f\"WHERE table_schema = '{schema}'\"\n return sql_cmd\ndef add(name, type_, column_name, dtype) -> str:\n return f\"ALTER {type_} {name} ADD {column_name} {dtype}\"\ndef drop(name: str, type_: str, column_name: str):\n \"\"\"\n Drop a column or object in table",
"score": 48.17443702758543
},
{
"filename": "acrocord/databasepg.py",
"retrieved_chunk": " \"\"\"\n Add key (reference between tables).\n Parameters\n ----------\n table_name: str\n The name of the table for which to add key\n key: str\n The name of the key (corresponds to a column in the table)\n type_: str\n The type of key. By default, the key type is a primary key. The",
"score": 41.7913442635314
},
{
"filename": "test/test_table_factory.py",
"retrieved_chunk": " assert c in ['building_id', 'architect', 'height',\n 'construction_date',\n 'is_constructed'], f\"column {c} is not in columns\"\n assert isinstance(get_table_factory.columns,\n list), \"columns attribute is not a list\"\ndef test_get_instance(get_table_factory):\n inst = get_table_factory.get_instance()\n assert inst._table is None\n inst.get_table()\ndef test_check_table_doc(get_table_factory):",
"score": 37.696885276224904
},
{
"filename": "acrocord/databasepg.py",
"retrieved_chunk": " - '': only the columns\n Default is 'cascade'\n type_:str\n The type of object can be either\n - a table and type_=\"TABLE\"\n - a view and type_=\"VIEW\"\n \"\"\"\n sql_cmd = f\"ALTER {type_} {table_name}\"\n for col in columns:\n sql_cmd += f\" DROP COLUMN {col} {option},\"",
"score": 35.82492069717655
}
] | python | get_list(), msg |
import os
from typing import List
import hnswlib
from vectorstore.vectorstore import Space, VectorStore
class HnswlibStore(VectorStore):
index: hnswlib.Index
# hnswlib params
dim: int
space: Space # ip, l2, or cosine
max_elements: int
# M: int # max number of connections on upper layers
# ef_construction: int # number of the nearest neighbors at index time
# ef_search: int # number of the nearest neighbors to search
def __init__(self, dim: int, space: Space, max_elements: int):
self.index = hnswlib.Index(space, dim)
self.index.init_index(max_elements)
self.dim = dim
self.max_elements = max_elements
self.space = space
def save(self, index_path: str):
self.index.save_index(index_path)
def load(self, index_path: str):
self.index.load_index(index_path, self.max_elements)
def add(self, embeddings: List[List[float]], labels: List[int]):
self.index.add_items(embeddings, labels)
def query(
self,
embeddings: List[List[float]],
top_k: int = 1,
) -> (List[List[int]], List[List[float]]):
"""
Take one or more embeddings and return the top_k embedding labels and
the original distances, defined by space, for each embedding.
"""
labels, distances = self.index.knn_query(embeddings, top_k)
if self.space == Space. | ip or self.space == Space.cosine: |
# https://github.com/nmslib/hnswlib returns a slightly different
# distances, change back to the original distances.
distances = 1.0 - distances
return labels, distances
| vectorstore/providers/hnswlib_store.py | JuniusLuo-VecLucene-8a47c91 | [
{
"filename": "vectorstore/vectorstore.py",
"retrieved_chunk": " def query(\n self,\n embeddings: List[List[float]],\n top_k: int = 1,\n ) -> (List[List[int]], List[List[float]]):\n \"\"\"\n Take one or more embeddings and return the top_k embedding ids and\n distances for each embedding.\n The distances are the original distances defined by the space, such as\n L2, inner/dot product, etc. The vector store provider should return the",
"score": 93.36366174687936
},
{
"filename": "index/vector_index.py",
"retrieved_chunk": " labels, distances = self.store.query(embeddings, top_k)\n # convert distances to scores\n return self._distance_to_scores(labels[0], distances[0])\n def _distance_to_scores(\n self, labels: List[int], distances: List[float],\n ) -> List[DocChunkScore]:\n # Convert the distances to the scores in range (0, 1),\n # higher score means closer.\n chunk_scores: List[DocChunkScore] = []\n for i, label in enumerate(labels):",
"score": 50.61291113487951
},
{
"filename": "index/vector_index.py",
"retrieved_chunk": " # update the doc_id_to_metas\n self.doc_id_to_metas[doc_id] = chunk_metas\n # add embeddings to the store\n self.store.add(chunk_embeddings, labels)\n def _get_embeddings(\n self, doc_path: str, batch_size: int = EMBEDDINGS_BATCH_SIZE,\n ) -> (List[List[float]], List[ChunkMetadata]):\n \"\"\"\n Split the doc's text into chunks, generate one embedding and metadata\n for each chunk.",
"score": 45.393186584238876
},
{
"filename": "tests/vectorstore/test_hnswlib.py",
"retrieved_chunk": " def verify_index_spaces(self, space: str):\n dim = 16\n max_elements = 5\n store = get_vector_store(\"hnswlib\", dim, space, max_elements)\n embeddings = np.float32(np.random.random((max_elements, dim)))\n labels = np.arange(max_elements)\n store.add(embeddings, labels)\n query_embeddings: List[List[float]] = []\n query_embeddings.append(embeddings[0])\n qlabels, distances = store.query(",
"score": 43.63076003519001
},
{
"filename": "vectorstore/vectorstore.py",
"retrieved_chunk": " Load the vectors from the file specified by index_path.\n \"\"\"\n raise NotImplementedError\n @abstractmethod\n def add(self, embeddings: List[List[float]], labels: List[int]):\n \"\"\"\n Add the embeddings and the corresponding labels.\n \"\"\"\n raise NotImplementedError\n @abstractmethod",
"score": 43.60882547766377
}
] | python | ip or self.space == Space.cosine: |
from os import getenv
from time import sleep
import pytest
from dotenv import load_dotenv
from pymilvus import Milvus, connections
from vectordb_orm import MilvusBackend, PineconeBackend, VectorSession
from vectordb_orm.tests.models import (MilvusBinaryEmbeddingObject,
MilvusMyObject, PineconeMyObject)
@pytest.fixture()
def milvus_session():
session = VectorSession(MilvusBackend(Milvus()))
connections.connect("default", host="localhost", port="19530")
# Wipe the previous collections
session.delete_collection(MilvusMyObject)
session.delete_collection(MilvusBinaryEmbeddingObject)
# Flush
sleep(1)
session.create_collection(MilvusMyObject)
session.create_collection(MilvusBinaryEmbeddingObject)
return session
@pytest.fixture()
def pinecone_session():
load_dotenv()
session = VectorSession(
PineconeBackend(
api_key=getenv("PINECONE_API_KEY"),
environment=getenv("PINECONE_ENVIRONMENT"),
)
)
# Wipe the previous collections
# Pinecone doesn't have the notion of binary objects like Milvus does, so we
# only create one object. Their free tier also doesn't support more than 1
# collection, so that's another limitation that encourages a single index here.
session.create_collection(PineconeMyObject)
session. | clear_collection(PineconeMyObject) |
return session
SESSION_FIXTURE_KEYS = ["milvus_session", "pinecone_session"]
SESSION_MODEL_PAIRS = [
(
"milvus_session",
MilvusMyObject,
),
(
"pinecone_session",
PineconeMyObject,
),
] | vectordb_orm/tests/conftest.py | piercefreeman-vectordb-orm-0b7fe7d | [
{
"filename": "vectordb_orm/backends/pinecone/pinecone.py",
"retrieved_chunk": " ):\n # Pinecone can't accept quotes in either parameters, and these are sometimes\n # unintentionally included in env variables\n # We quit before initializing with a more informative error message\n if \"'\" in api_key or '\"' in api_key:\n raise ValueError(\"Pinecone `api_key` contains single or double quotes, which isn't allowed.\")\n if \"'\" in environment or '\"' in environment:\n raise ValueError(\"Pinecone `environment` contains single or double quotes, which isn't allowed.\")\n pinecone.init(\n api_key=api_key,",
"score": 33.55878507704487
},
{
"filename": "vectordb_orm/backends/pinecone/pinecone.py",
"retrieved_chunk": " limit: int,\n offset: int,\n ):\n # For performance reasons, do not return vector metadata when top_k>1000\n # A ORM search query automatically returns some fields, so we need to\n # throw an error under these conditions\n if limit > 1000:\n raise ValueError(\"Pinecone only supports retrieving element values with limit <= 1000\")\n if offset > 0:\n raise ValueError(\"Pinecone doesn't currently support query offsets\")",
"score": 32.80915220153244
},
{
"filename": "vectordb_orm/backends/pinecone/pinecone.py",
"retrieved_chunk": " # Success should have an empty dict\n raise ValueError(f\"Failed to clear collection {collection_name}: {delete_response}\")\n def delete_collection(self, schema: Type[VectorSchemaBase]):\n collection_name = self.transform_collection_name(schema.collection_name())\n # Pinecone throws a 404 if the index doesn't exist\n current_indexes = pinecone.list_indexes()\n if collection_name not in current_indexes:\n return\n pinecone.delete_index(collection_name)\n def insert(self, entity: VectorSchemaBase) -> list:",
"score": 27.89239964189799
},
{
"filename": "vectordb_orm/backends/pinecone/pinecone.py",
"retrieved_chunk": " self._assert_has_primary(schema)\n self._assert_valid_embedding_field(schema)\n # Pinecone allows for dynamic keys on each object\n # However we need to pre-provide the keys we want to search on\n # This does increase memory size so we can consider adding an explict index flag\n # for the metadata fields that we want to allow search on\n # https://docs.pinecone.io/docs/manage-indexes#selective-metadata-indexing\n metadata_config = {\n \"indexed\": [\n key",
"score": 27.87517168521032
},
{
"filename": "vectordb_orm/backends/base.py",
"retrieved_chunk": " if isinstance(schema._type_configuration.get(attribute_name), PrimaryKeyField):\n return attribute_name\n return None\n def _assert_has_primary(self, schema: Type[VectorSchemaBase]):\n \"\"\"\n Ensure we have a primary key, this is the only field that's fully required\n \"\"\"\n if self._get_primary(schema) is None:\n raise ValueError(f\"Class {schema.__name__} does not have a primary key, specify `PrimaryKeyField` on the class definition.\")",
"score": 26.36725838628377
}
] | python | clear_collection(PineconeMyObject) |
import numpy as np
from vectordb_orm import (ConsistencyType, EmbeddingField, Milvus_BIN_FLAT,
Milvus_IVF_FLAT, PineconeIndex,
PineconeSimilarityMetric, PrimaryKeyField,
VarCharField, VectorSchemaBase)
class MilvusMyObject(VectorSchemaBase):
__collection_name__ = 'my_collection'
__consistency_type__ = ConsistencyType.STRONG
id: int = PrimaryKeyField()
text: str = VarCharField(max_length=128)
embedding: np.ndarray = EmbeddingField(dim=128, index=Milvus_IVF_FLAT(cluster_units=128))
class MilvusBinaryEmbeddingObject(VectorSchemaBase):
__collection_name__ = 'binary_collection'
__consistency_type__ = ConsistencyType.STRONG
id: int = PrimaryKeyField()
embedding: np.ndarray[np.bool_] = EmbeddingField(dim=128, index=Milvus_BIN_FLAT())
class PineconeMyObject(VectorSchemaBase):
__collection_name__ = 'my_collection'
id: int = PrimaryKeyField()
text: str = VarCharField(max_length=128)
embedding: np.ndarray = EmbeddingField(dim=128, index=PineconeIndex(metric_type=PineconeSimilarityMetric. | COSINE)) | vectordb_orm/tests/models.py | piercefreeman-vectordb-orm-0b7fe7d | [
{
"filename": "vectordb_orm/tests/milvus/test_indexes.py",
"retrieved_chunk": " class IndexSubclassObject(VectorSchemaBase):\n __collection_name__ = 'index_collection'\n id: int = PrimaryKeyField()\n embedding: np.ndarray[np.bool_] = EmbeddingField(\n dim=128,\n index=index_cls(\n metric_type=metric_type,\n **INDEX_DEFAULTS.get(index_cls.index_type, {})\n )\n )",
"score": 72.08013866199931
},
{
"filename": "vectordb_orm/tests/test_base.py",
"retrieved_chunk": " results = session.query(model).filter(model.text == \"example\").all()\n assert len(results) == 0\ndef test_milvus_invalid_typesignatures(milvus_session: VectorSession):\n class TestInvalidObject(VectorSchemaBase):\n \"\"\"\n An IVF_FLAT can't be used with a boolean embedding type\n \"\"\"\n __collection_name__ = 'invalid_collection'\n id: int = PrimaryKeyField()\n embedding: np.ndarray[np.bool_] = EmbeddingField(dim=128, index=Milvus_IVF_FLAT(cluster_units=128))",
"score": 58.15798748107809
},
{
"filename": "vectordb_orm/tests/milvus/test_indexes.py",
"retrieved_chunk": ")\ndef test_floating_index(\n milvus_session: VectorSession,\n index_cls: MilvusIndexBase,\n metric_type: MilvusFloatSimilarityMetric,\n):\n class IndexSubclassObject(VectorSchemaBase):\n __collection_name__ = 'index_collection'\n id: int = PrimaryKeyField()\n embedding: np.ndarray = EmbeddingField(",
"score": 50.606136281276044
},
{
"filename": "vectordb_orm/tests/test_base.py",
"retrieved_chunk": " is_valid: bool\n embedding: np.ndarray = EmbeddingField(dim=128, index=Milvus_IVF_FLAT(cluster_units=128))\n milvus_session.create_collection(TestMixedConfigurationObject)",
"score": 45.27080742741672
},
{
"filename": "vectordb_orm/tests/milvus/test_indexes.py",
"retrieved_chunk": " dim=128,\n index=index_cls(\n metric_type=metric_type,\n **INDEX_DEFAULTS.get(index_cls.index_type, {})\n )\n )\n milvus_session.delete_collection(IndexSubclassObject)\n milvus_session.create_collection(IndexSubclassObject)\n # Insert an object\n my_object = IndexSubclassObject(embedding=np.array([1.0] * 128))",
"score": 30.491390941609296
}
] | python | COSINE)) |
|
import numpy as np
import pytest
from vectordb_orm import VectorSession
from vectordb_orm.tests.models import MilvusBinaryEmbeddingObject
# @pierce 04-21- 2023: Currently flaky
# https://github.com/piercefreeman/vectordb-orm/pull/5
@pytest.mark.xfail(strict=False)
def test_binary_collection_query(session: VectorSession):
# Create some MyObject instances
obj1 = MilvusBinaryEmbeddingObject(embedding=np.array([True] * 128))
obj2 = MilvusBinaryEmbeddingObject(embedding=np.array([False] * 128))
# Insert the objects into Milvus
session.insert(obj1)
session.insert(obj2)
session.flush(MilvusBinaryEmbeddingObject)
session.load(MilvusBinaryEmbeddingObject)
# Test our ability to recall 1:1 the input content
results = session.query(MilvusBinaryEmbeddingObject).order_by_similarity(MilvusBinaryEmbeddingObject. | embedding, np.array([True]*128)).limit(2).all() |
assert len(results) == 2
assert results[0].result.id == obj1.id
results = session.query(MilvusBinaryEmbeddingObject).order_by_similarity(BinaryEmbeddingObject.embedding, np.array([False]*128)).limit(2).all()
assert len(results) == 2
assert results[0].result.id == obj2.id
| vectordb_orm/tests/milvus/test_milvus.py | piercefreeman-vectordb-orm-0b7fe7d | [
{
"filename": "vectordb_orm/tests/test_query.py",
"retrieved_chunk": " session : VectorSession = request.getfixturevalue(session)\n # Create some MyObject instances\n obj1 = model(text=\"foo\", embedding=np.array([1.0] * 128))\n obj2 = model(text=\"bar\", embedding=np.array([4.0] * 128))\n obj3 = model(text=\"baz\", embedding=np.array([7.0] * 128))\n # Insert the objects into Milvus\n session.insert(obj1)\n session.insert(obj2)\n session.insert(obj3)\n session.flush(model)",
"score": 96.16197987725077
},
{
"filename": "vectordb_orm/tests/test_base.py",
"retrieved_chunk": " obj1 = model(text='example1', embedding=np.array([1.0] * 128))\n obj2 = model(text='example2', embedding=np.array([2.0] * 128))\n obj3 = model(text='example3', embedding=np.array([3.0] * 128))\n session.insert_batch([obj1, obj2, obj3])\n for obj in [obj1, obj2, obj3]:\n assert obj.id is not None\[email protected](\"session,model\", SESSION_MODEL_PAIRS)\ndef test_delete_object(session: str, model: Type[VectorSchemaBase],request):\n session : VectorSession = request.getfixturevalue(session)\n my_object = model(text='example', embedding=np.array([1.0] * 128))",
"score": 78.47481837309786
},
{
"filename": "vectordb_orm/tests/test_query.py",
"retrieved_chunk": " session.load(model)\n # Test a simple filter and similarity ranking\n results = session.query(model).filter(model.text == 'bar').order_by_similarity(model.embedding, np.array([1.0]*128)).limit(2).all()\n assert len(results) == 1\n assert results[0].result.id == obj2.id\n # Test combined filtering\n results = session.query(model).filter(model.text == 'baz', model.id > 1).order_by_similarity(model.embedding, np.array([8.0]*128)).limit(2).all()\n assert len(results) == 1\n assert results[0].result.id == obj3.id\[email protected](\"session,model\", SESSION_MODEL_PAIRS)",
"score": 74.91966414022053
},
{
"filename": "vectordb_orm/tests/test_query.py",
"retrieved_chunk": " session : VectorSession = request.getfixturevalue(session)\n obj1 = model(text=\"foo\", embedding=np.array([1.0] * 128))\n session.insert(obj1)\n session.flush(model)\n session.load(model)\n # We can query for regular attributes\n results = session.query(model.text).filter(model.text == 'foo').all()\n assert len(results) == 1\n # We shouldn't be able to query for embeddings\n with pytest.raises(ValueError):",
"score": 67.95952799017007
},
{
"filename": "vectordb_orm/tests/milvus/test_indexes.py",
"retrieved_chunk": " milvus_session.delete_collection(IndexSubclassObject)\n milvus_session.create_collection(IndexSubclassObject)\n # Insert an object\n my_object = IndexSubclassObject(embedding=np.array([True] * 128))\n milvus_session.insert(my_object)\n # Flush and load the collection\n milvus_session.flush(IndexSubclassObject)\n milvus_session.load(IndexSubclassObject)\n # Perform a query\n results = milvus_session.query(IndexSubclassObject).order_by_similarity(IndexSubclassObject.embedding, np.array([True] * 128)).all()",
"score": 67.05025527440795
}
] | python | embedding, np.array([True]*128)).limit(2).all() |
import abc
import logging
import os
from collections import OrderedDict
import torch
import torch.nn as nn
from clip import clip
from detoxify import Detoxify
from isc_feature_extractor import create_model
from dataset2metadata.utils import download
from dataset2metadata.face_detection.scrfd_wrapper import FaceDetector
logging.getLogger().setLevel(logging.INFO)
class WrapperMixin(metaclass=abc.ABCMeta):
pass
class OaiClipWrapper(nn.Module, WrapperMixin, metaclass=abc.ABCMeta):
def __init__(self, model_name: str, device: str) -> None:
super().__init__()
self.model, _ = clip.load(model_name, device=device)
self.model.eval()
def forward(self, x, t):
image_feature = self.model.encode_image(x)
text_feature = self.model.encode_text(t)
# normalized features
image_feature = image_feature / image_feature.norm(dim=1, keepdim=True)
text_feature = text_feature / text_feature.norm(dim=1, keepdim=True)
return image_feature, text_feature
class OaiClipVitB32Wrapper(OaiClipWrapper):
name = "oai-clip-vit-b32"
raw_inputs = ["image", "text"]
preprocessors = ["clip-aug", "clip-tokens"]
dependencies = []
to_device = True
def __init__(self, device) -> None:
super().__init__("ViT-B/32", device)
logging.info(f"instantiated {self.name} on {device}")
class OaiClipVitL14Wrapper(OaiClipWrapper):
name = "oai-clip-vit-l14"
raw_inputs = ["image", "text"]
preprocessors = ["clip-aug", "clip-tokens"]
dependencies = []
to_device = True
def __init__(self, device) -> None:
super().__init__("ViT-L/14", device)
logging.info(f"instantiated {self.name} on {device}")
class DetoxifyWrapper(nn.Module, WrapperMixin):
name = "nsfw-detoxify"
raw_inputs = [
"text",
]
preprocessors = [
"identity",
]
dependencies = []
to_device = False
def __init__(self, device) -> None:
super().__init__()
self.model = Detoxify("multilingual", device=f"cuda:{device}")
logging.info(f"instantiated {self.name} on {device}")
def forward(self, t):
scores = []
preds = self.model.predict(t)
for _, v in preds.items():
scores.append(v)
# column-wise max score
maxi, _ = torch.tensor(scores).transpose(0, 1).max(axis=1)
return maxi
class NsfwImageWrapper(nn.Module, WrapperMixin):
name = "nsfw-image-oai-clip-vit-l-14"
raw_inputs = []
preprocessors = []
dependencies = ["oai-clip-vit-l14"]
to_device = True
def __init__(self, device) -> None:
super().__init__()
self.model = self.load(download("nsfw-image"))
self.model.to(device).eval()
logging.info(f"instantiated {self.name} on {device}")
def load(self, classifier_path):
names = [
"norm",
"dense",
"relu",
"dense1",
"relu1",
"dense2",
"relu2",
"dense3",
"sigmoid",
]
model = nn.Sequential(
OrderedDict(
[
(names[0], nn.BatchNorm1d(768, eps=0.0)),
(names[1], nn.Linear(768, 64)),
(names[2], nn.ReLU()),
(names[3], nn.Linear(64, 512)),
(names[4], nn.ReLU()),
(names[5], nn.Linear(512, 256)),
(names[6], nn.ReLU()),
(names[7], nn.Linear(256, 1)),
(names[8], nn.Sigmoid()),
]
)
)
state_dict = torch.load(classifier_path, map_location="cpu")
model.load_state_dict(state_dict)
return model
def forward(self, z):
# use only the image feature
return self.model(z[0].float()).squeeze()
class IscFtV107Wrapper(nn.Module, WrapperMixin):
name = "dedup-isc-ft-v107"
raw_inputs = [
"image",
]
preprocessors = [
"dedup-aug",
]
dependencies = []
to_device = True
def __init__(self, device) -> None:
super().__init__()
self.model, _ = create_model(weight_name="isc_ft_v107", device=device)
self.model.eval()
self.reference_embeddings = (
torch.load(download("dedup-embeddings")).to(device).t()
)
self.reference_embeddings.requires_grad = False
logging.info(f"instantiated {self.name} on {device}")
def forward(self, x):
z = self.model(x)
z /= z.norm(dim=-1, keepdim=True)
scores = z @ self.reference_embeddings # (b,c) @ (c,n) = (b,n)
max_scores, _ = scores.max(axis=1)
return z, max_scores
class Scrfd10GWrapper(nn.Module, WrapperMixin):
name = "faces-scrfd10g"
raw_inputs = [
"image",
]
preprocessors = [
"faces-aug",
]
dependencies = []
to_device = True
def __init__(self, device) -> None:
super().__init__()
self.model = FaceDetector(download("faces-scrfd10g"), device)
logging.info(f"instantiated {self.name} on {device}")
def forward(self, x):
return self.model. | detect_faces(images=x[0], paddings=x[1]) | dataset2metadata/models.py | mlfoundations-dataset2metadata-a673a83 | [
{
"filename": "dataset2metadata/face_detection/scrfd_wrapper.py",
"retrieved_chunk": " return model\nclass FaceDetector(object):\n def __init__(self, checkpoint_path: str, device: int = 0) -> None:\n if device < 0:\n self.device = \"cpu\"\n else:\n if not torch.cuda.is_available():\n raise RuntimeError(\"CUDA is not available. Consider setting gpu = -1.\")\n else:\n self.device = f\"cuda:{device}\"",
"score": 42.54874261807022
},
{
"filename": "dataset2metadata/process.py",
"retrieved_chunk": " )\n # initializing models\n models = {m_str: model_lookup[m_str](yml['device']) for m_str in yml['models']}\n # deciding order to run them in based on dependencies\n topsort_order = topsort(\n {m_str: model_lookup[m_str].dependencies for m_str in yml['models']}\n )\n logging.info(f'topsort model evaluation order: {topsort_order}')\n # initialize the writer that stores results and dumps them to store\n # TODO: fix the name here",
"score": 34.917203029606554
},
{
"filename": "dataset2metadata/face_detection/scrfd_wrapper.py",
"retrieved_chunk": " )\n return result\n def detect_faces(\n self,\n images: torch.Tensor,\n paddings: torch.Tensor,\n score_threshold: float = 0.3,\n ):\n \"\"\"Detect faces.\n Args:",
"score": 29.955987944668244
},
{
"filename": "dataset2metadata/face_detection/backbone.py",
"retrieved_chunk": " x = res_layer(x)\n if i in self.out_indices:\n outs.append(x)\n return tuple(outs)\n def train(self, mode=True):\n \"\"\"Convert the model into training mode while keep normalization layer\n freezed.\"\"\"\n super(ResNet, self).train(mode)\n self._freeze_stages()\n if mode and self.norm_eval:",
"score": 28.521824361187935
},
{
"filename": "dataset2metadata/face_detection/head.py",
"retrieved_chunk": " * self.strides[level_idx][1]\n )\n priors = torch.stack([x, y, x, y], 1).to(dtype).to(device) + self.base_anchors[\n level_idx\n ][base_anchor_id, :].to(device)\n return priors\n def grid_anchors(self, featmap_sizes, device=\"cuda\"):\n \"\"\"Generate grid anchors in multiple feature levels.\n Args:\n featmap_sizes (list[tuple]): List of feature map sizes in",
"score": 26.391432097287748
}
] | python | detect_faces(images=x[0], paddings=x[1]) |
|
import os
import pathlib
from importlib.machinery import SourceFileLoader
from typing import List
import torch
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import hashlib
import logging
from pathlib import Path
import fsspec
import yaml
from PIL import ImageFile
from dataset2metadata.dataloaders import create_loader
from dataset2metadata.registry import update_registry
from dataset2metadata.utils import topsort
from dataset2metadata.writer import Writer
ImageFile.LOAD_TRUNCATED_IMAGES = True
logging.getLogger().setLevel(logging.INFO)
def check_yml(yml):
# manditory fields in the yml
yml_fields = [
'models',
'nworkers',
'batch_size',
'device',
'input_tars',
'output_metadata_dir',
]
yml_optional_fields = [
'postprocess_columns',
'postprocess_features',
'additional_fields',
'custom_pypath',
'reprocess',
'use_datacomp_keys'
]
for f in yml_fields:
if f not in yml:
raise ValueError(f'missing required yml field: {f}')
for f in yml:
if f not in yml_fields + yml_optional_fields:
raise ValueError(f'unknown field: {f}')
def process(
yml,
):
if type(yml) is str:
# parse yml and check resulting dict
yml = yaml.safe_load(Path(yml).read_text())
check_yml(yml)
# if local out dir does not exist make it
fs, output_path = fsspec.core.url_to_fs(yml['output_metadata_dir'])
fs.makedirs(output_path, exist_ok=True)
# assign a name to the group of shards being processed
name = hashlib.md5(str(yml['input_tars']).encode()).hexdigest()
# cache if result already there and user does not want to reprocess
if 'reprocess' not in yml or not yml['reprocess']:
# cache
completed = fs.ls(output_path)
completed_parquets = [p for p in completed if 'parquet' in p]
if name in set([Path(s).stem for s in completed_parquets]):
logging.info(f'found cached result: {name}')
return
# if the user specifies specific custom implementaion of their own update the registry
if 'custom_pypath' in yml and yml['custom_pypath'] is not None:
custom = SourceFileLoader(
pathlib.Path(yml['custom_pypath']).stem,
yml['custom_pypath']
).load_module()
update_registry(custom)
# import from registry here after we have updated
from dataset2metadata.registry import (model_lookup,
postprocess_feature_lookup,
postprocess_parquet_lookup)
# create dataloader based on user input
dataloader, input_map = create_loader(
yml['input_tars'],
yml['models'],
yml['additional_fields'],
yml['nworkers'],
yml['batch_size'],
)
# initializing models
models = {m_str: model_lookup[m_str](yml['device']) for m_str in yml['models']}
# deciding order to run them in based on dependencies
topsort_order = topsort(
{m_str: model_lookup[m_str].dependencies for m_str in yml['models']}
)
logging.info(f'topsort model evaluation order: {topsort_order}')
# initialize the writer that stores results and dumps them to store
# TODO: fix the name here
feature_fields = []
parquet_fields = []
if 'postprocess_features' in yml:
feature_fields = yml['postprocess_features']
if 'postprocess_columns' in yml:
parquet_fields.extend(yml['postprocess_columns'])
if 'additional_fields' in yml:
parquet_fields.extend(yml['additional_fields'])
writer = Writer(
name,
feature_fields,
parquet_fields,
yml['use_datacomp_keys'] if 'use_datacomp_keys' in yml else False
)
for sample in dataloader:
model_outputs = {}
# eval all models sequentially in a top sort order
for m_str in topsort_order:
model_input = []
cache = {}
# fill the model input
for i in input_map[m_str]:
if isinstance(i, int):
if models[m_str].to_device and i not in cache:
if isinstance(sample[i], List):
# if list needs to be moved to device transpose and move it
sample[i] = list(zip(*sample[i]))
for j in range(len(sample[i])):
sample[i][j] = torch.cat(sample[i][j]).to(yml['device'])
cache[i] = sample[i]
else:
cache[i] = sample[i].to(yml['device'])
else:
cache[i] = sample[i]
model_input.append(cache[i])
else:
# use previously computed outputs and new inputs
# NOTE: assume downstream model consumes on same device as upstream
assert i in model_outputs
model_input.append(model_outputs[i])
with torch.no_grad():
model_outputs[m_str] = models[m_str](*model_input)
# TODO: make this more general, right now assumes last entry is json fields
if len(yml['additional_fields']):
model_outputs['json'] = sample[-1]
if 'postprocess_features' in yml:
for k in yml['postprocess_features']:
writer. | update_feature_store(k, postprocess_feature_lookup[k](model_outputs)) |
if 'postprocess_columns' in yml:
for k in yml['postprocess_columns']:
writer.update_parquet_store(k, postprocess_parquet_lookup[k](model_outputs))
# if additional fields from json need to be saved, add those to the store
if 'additional_fields' in yml and len(yml['additional_fields']):
transposed_additional_fields = postprocess_parquet_lookup['json-transpose'](model_outputs)
assert len(transposed_additional_fields) == len(yml['additional_fields'])
for i, v in enumerate(transposed_additional_fields):
writer.update_parquet_store(yml['additional_fields'][i], v)
writer.write(yml['output_metadata_dir'])
| dataset2metadata/process.py | mlfoundations-dataset2metadata-a673a83 | [
{
"filename": "examples/slurm/prepare_jobs.py",
"retrieved_chunk": " print(f\"num shards: {len(shards)}\")\n print(f\"num jobs: {len(groups)}\")\n for i, g in enumerate(groups):\n yml_template[\"input_tars\"] = g\n with open(os.path.join(jobs_dir_path, f\"{i}.yml\"), \"w\") as f:\n for k in yml_template:\n f.write(f\"{k}:\")\n if not isinstance(yml_template[k], list):\n f.write(f\" {yml_template[k]}\\n\")\n else:",
"score": 43.56111087973275
},
{
"filename": "dataset2metadata/dataloaders.py",
"retrieved_chunk": " else:\n input_map[models[i]].append(unique_derectives.index(preprocess_directives[j]))\n if len(model_class.dependencies):\n # non-numeric, nameded dependencies, i.e., the outputs of other models\n input_map[models[i]].extend(model_class.dependencies)\n # add directives to include data from the tars into the webdataset\n if additional_fields is not None and len(additional_fields):\n # NOTE: currently no support for these additional fields being taken as inputs to models\n input_map['json'] = [len(unique_derectives), ]\n unique_derectives.append(('json', 'identity'))",
"score": 41.06452421230398
},
{
"filename": "dataset2metadata/dataloaders.py",
"retrieved_chunk": " for i, model_class in enumerate(wrapper_classes):\n assert len(model_class.preprocessors) == len(model_class.raw_inputs)\n preprocess_directives = [\n (model_class.raw_inputs[k], model_class.preprocessors[k]) for k in range(len(model_class.preprocessors))\n ]\n input_map[models[i]] = []\n for j in range(len(preprocess_directives)):\n if preprocess_directives[j] not in unique_derectives:\n input_map[models[i]].append(len(unique_derectives))\n unique_derectives.append(preprocess_directives[j])",
"score": 39.70910464252847
},
{
"filename": "dataset2metadata/writer.py",
"retrieved_chunk": " # store other metadata like image height, ultimately in a parquet\n self.parquet_store = {e: [] for e in parquet_fields}\n # if true, then we will remap keys using d2m_to_datacomp_keys for some fields\n self.use_datacomp_keys = use_datacomp_keys\n def update_feature_store(self, k, v):\n if self.use_datacomp_keys:\n if k in d2m_to_datacomp_keys:\n self.feature_store[d2m_to_datacomp_keys[k]].append(v)\n else:\n self.feature_store[k].append(v)",
"score": 38.174604274180254
},
{
"filename": "dataset2metadata/preprocessors.py",
"retrieved_chunk": " return DEDUP_IMAGE_TRANFORM(x)\ndef json_decoder(key, value, json_keys):\n if not key.endswith(\"json\") or json_keys is None:\n return None\n json_dict = JSON_PARSER.parse(value).as_dict()\n return [json_dict[k] for k in json_keys]\ndef identity(a):\n return a",
"score": 33.345009547973376
}
] | python | update_feature_store(k, postprocess_feature_lookup[k](model_outputs)) |
from omegaconf import OmegaConf
import torch
from torch.optim.lr_scheduler import MultiStepLR
from ..models.gnn_ssl import GnnSslNet
from ..metrics import Loss
from .base import BaseTrainer
class GnnSslNetTrainer(BaseTrainer):
"""This class abstracts the
training/validation/testing procedures
used for training a GnnSslNet
"""
def __init__(self, config):
super().__init__(config)
self.rmse = Loss(config["targets"], mode="l2", dim=1)
def _step(self, batch, batch_idx, log_model_output=False, log_labels=False):
"""This is the base step done on every training, validation and testing batch iteration.
This had to be overriden since we are using multiple datasets
"""
loss_vectors = []
outputs = []
targets = []
n_mics = []
# Loop for every microphone number
for (x, y) in batch:
n = x["signal"].shape[1]
# 1. Compute model output and loss
output = self.model(x)
loss = self.loss(output, y, mean_reduce=False)
outputs.append(output)
targets.append(y)
loss_vectors.append(loss)
n_mics.append(n)
# 2. RMSE
rmse_error = self.rmse(output, y, mean_reduce=True)
self. | log(f"rmse_{n}_mics", rmse_error, on_step=True, prog_bar=False, on_epoch=False) |
output_dict = {}
for i, n in enumerate(n_mics):
loss_vector = loss_vectors[i]
mean_loss = loss_vector.mean()
output_dict[f"loss_vector_{n}"] = loss_vector.detach().cpu()
output_dict[f"mean_loss_{n}"] = mean_loss.detach().cpu()
# TODO: Add these to a callback
# 2. Log model output
if log_model_output:
output_dict[f"model_outputs_{n}"] = outputs[i]
output_dict["loss"] = torch.stack(loss_vectors).mean()
return output_dict
| gnn_ssl/trainers/gnn_ssl.py | egrinstein-gnn_ssl-74c7b5a | [
{
"filename": "gnn_ssl/trainers/base.py",
"retrieved_chunk": " def forward(self, x):\n return self.model(x)\n def _step(self, batch, batch_idx, epoch_type):\n x, y = batch[0] # 0 is to ignore the microphone array index\n # 1. Compute model output and loss\n x = self.forward(x)\n loss = self.loss(x, y, mean_reduce=True)\n self.log_dict({f\"{epoch_type}_loss_step\": loss})\n return {\n \"loss\": loss",
"score": 60.8831588608867
},
{
"filename": "gnn_ssl/metrics.py",
"retrieved_chunk": "class ExampleLoss(torch.nn.Module):\n def __init__(self, config):\n super().__init__()\n self.config = config\n def forward(self, model_output, targets, mean_reduce=True):\n x = model_output[\"example_output\"]\n # Don't do anything with targets, just return the output\n if mean_reduce:\n x = x.mean()\n return x",
"score": 45.7679342354185
},
{
"filename": "gnn_ssl/metrics.py",
"retrieved_chunk": " # Compute loss\n loss = self.loss(model_output, targets)\n if self.weighted:\n loss *= targets\n if mean_reduce:\n if self.weighted:\n loss = loss.sum()/loss.shape[0]\n else:\n loss = loss.mean()\n return loss",
"score": 40.69971833274419
},
{
"filename": "visualize_outputs.py",
"retrieved_chunk": " # 3. Load loss function\n loss = get_class(config[\"targets\"][\"loss_class\"])(config[\"targets\"])\n # Compute outputs for a single batch\n x, y = batch = next(iter(dataset_test))[0]\n model_outputs = {\n model_name: model[\"model\"](x)\n for model_name, model in models.items()\n }\n create_visualizations(model_outputs, y, loss, plot_target=False)\nif __name__ == \"__main__\":",
"score": 39.759186664408254
},
{
"filename": "gnn_ssl/trainers/base.py",
"retrieved_chunk": " tensorboard_logs = {\n f\"{epoch_type}_loss\": outputs[\"loss\"].mean(),\n # f\"{epoch_type}_std\": outputs[\"loss\"].std(),\n \"step\": self.current_epoch\n }\n print(tensorboard_logs)\n self.log_dict(tensorboard_logs)\n def training_epoch_end(self, outputs):\n self._epoch_end(outputs)\n def validation_epoch_end(self, outputs):",
"score": 33.364156305578746
}
] | python | log(f"rmse_{n}_mics", rmse_error, on_step=True, prog_bar=False, on_epoch=False) |
import os
import pathlib
from importlib.machinery import SourceFileLoader
from typing import List
import torch
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import hashlib
import logging
from pathlib import Path
import fsspec
import yaml
from PIL import ImageFile
from dataset2metadata.dataloaders import create_loader
from dataset2metadata.registry import update_registry
from dataset2metadata.utils import topsort
from dataset2metadata.writer import Writer
ImageFile.LOAD_TRUNCATED_IMAGES = True
logging.getLogger().setLevel(logging.INFO)
def check_yml(yml):
# manditory fields in the yml
yml_fields = [
'models',
'nworkers',
'batch_size',
'device',
'input_tars',
'output_metadata_dir',
]
yml_optional_fields = [
'postprocess_columns',
'postprocess_features',
'additional_fields',
'custom_pypath',
'reprocess',
'use_datacomp_keys'
]
for f in yml_fields:
if f not in yml:
raise ValueError(f'missing required yml field: {f}')
for f in yml:
if f not in yml_fields + yml_optional_fields:
raise ValueError(f'unknown field: {f}')
def process(
yml,
):
if type(yml) is str:
# parse yml and check resulting dict
yml = yaml.safe_load(Path(yml).read_text())
check_yml(yml)
# if local out dir does not exist make it
fs, output_path = fsspec.core.url_to_fs(yml['output_metadata_dir'])
fs.makedirs(output_path, exist_ok=True)
# assign a name to the group of shards being processed
name = hashlib.md5(str(yml['input_tars']).encode()).hexdigest()
# cache if result already there and user does not want to reprocess
if 'reprocess' not in yml or not yml['reprocess']:
# cache
completed = fs.ls(output_path)
completed_parquets = [p for p in completed if 'parquet' in p]
if name in set([Path(s).stem for s in completed_parquets]):
logging.info(f'found cached result: {name}')
return
# if the user specifies specific custom implementaion of their own update the registry
if 'custom_pypath' in yml and yml['custom_pypath'] is not None:
custom = SourceFileLoader(
pathlib.Path(yml['custom_pypath']).stem,
yml['custom_pypath']
).load_module()
update_registry(custom)
# import from registry here after we have updated
from dataset2metadata.registry import (model_lookup,
postprocess_feature_lookup,
postprocess_parquet_lookup)
# create dataloader based on user input
dataloader, input_map = create_loader(
yml['input_tars'],
yml['models'],
yml['additional_fields'],
yml['nworkers'],
yml['batch_size'],
)
# initializing models
models = {m_str: model_lookup[m_str](yml['device']) for m_str in yml['models']}
# deciding order to run them in based on dependencies
topsort_order = topsort(
{m_str: model_lookup[m_str].dependencies for m_str in yml['models']}
)
logging.info(f'topsort model evaluation order: {topsort_order}')
# initialize the writer that stores results and dumps them to store
# TODO: fix the name here
feature_fields = []
parquet_fields = []
if 'postprocess_features' in yml:
feature_fields = yml['postprocess_features']
if 'postprocess_columns' in yml:
parquet_fields.extend(yml['postprocess_columns'])
if 'additional_fields' in yml:
parquet_fields.extend(yml['additional_fields'])
writer = Writer(
name,
feature_fields,
parquet_fields,
yml['use_datacomp_keys'] if 'use_datacomp_keys' in yml else False
)
for sample in dataloader:
model_outputs = {}
# eval all models sequentially in a top sort order
for m_str in topsort_order:
model_input = []
cache = {}
# fill the model input
for i in input_map[m_str]:
if isinstance(i, int):
if models[m_str].to_device and i not in cache:
if isinstance(sample[i], List):
# if list needs to be moved to device transpose and move it
sample[i] = list(zip(*sample[i]))
for j in range(len(sample[i])):
sample[i][j] = torch.cat(sample[i][j]).to(yml['device'])
cache[i] = sample[i]
else:
cache[i] = sample[i].to(yml['device'])
else:
cache[i] = sample[i]
model_input.append(cache[i])
else:
# use previously computed outputs and new inputs
# NOTE: assume downstream model consumes on same device as upstream
assert i in model_outputs
model_input.append(model_outputs[i])
with torch.no_grad():
model_outputs[m_str] = models[m_str](*model_input)
# TODO: make this more general, right now assumes last entry is json fields
if len(yml['additional_fields']):
model_outputs['json'] = sample[-1]
if 'postprocess_features' in yml:
for k in yml['postprocess_features']:
writer.update_feature_store(k, postprocess_feature_lookup[k](model_outputs))
if 'postprocess_columns' in yml:
for k in yml['postprocess_columns']:
writer.update_parquet_store(k, postprocess_parquet_lookup[k](model_outputs))
# if additional fields from json need to be saved, add those to the store
if 'additional_fields' in yml and len(yml['additional_fields']):
transposed_additional_fields = postprocess_parquet_lookup['json-transpose'](model_outputs)
assert len(transposed_additional_fields) == len(yml['additional_fields'])
for i, v in enumerate(transposed_additional_fields):
writer.update_parquet_store(yml['additional_fields'][i], v)
writer. | write(yml['output_metadata_dir']) | dataset2metadata/process.py | mlfoundations-dataset2metadata-a673a83 | [
{
"filename": "examples/slurm/prepare_jobs.py",
"retrieved_chunk": " print(f\"num shards: {len(shards)}\")\n print(f\"num jobs: {len(groups)}\")\n for i, g in enumerate(groups):\n yml_template[\"input_tars\"] = g\n with open(os.path.join(jobs_dir_path, f\"{i}.yml\"), \"w\") as f:\n for k in yml_template:\n f.write(f\"{k}:\")\n if not isinstance(yml_template[k], list):\n f.write(f\" {yml_template[k]}\\n\")\n else:",
"score": 73.56862444363492
},
{
"filename": "dataset2metadata/dataloaders.py",
"retrieved_chunk": " else:\n input_map[models[i]].append(unique_derectives.index(preprocess_directives[j]))\n if len(model_class.dependencies):\n # non-numeric, nameded dependencies, i.e., the outputs of other models\n input_map[models[i]].extend(model_class.dependencies)\n # add directives to include data from the tars into the webdataset\n if additional_fields is not None and len(additional_fields):\n # NOTE: currently no support for these additional fields being taken as inputs to models\n input_map['json'] = [len(unique_derectives), ]\n unique_derectives.append(('json', 'identity'))",
"score": 70.2705685968767
},
{
"filename": "dataset2metadata/writer.py",
"retrieved_chunk": " else:\n self.feature_store[k].append(v)\n def update_parquet_store(self, k, v):\n if self.use_datacomp_keys:\n if k in d2m_to_datacomp_keys:\n self.parquet_store[d2m_to_datacomp_keys[k]].append(v)\n else:\n self.parquet_store[k].append(v)\n else:\n self.parquet_store[k].append(v)",
"score": 59.52776776183039
},
{
"filename": "dataset2metadata/writer.py",
"retrieved_chunk": " # store other metadata like image height, ultimately in a parquet\n self.parquet_store = {e: [] for e in parquet_fields}\n # if true, then we will remap keys using d2m_to_datacomp_keys for some fields\n self.use_datacomp_keys = use_datacomp_keys\n def update_feature_store(self, k, v):\n if self.use_datacomp_keys:\n if k in d2m_to_datacomp_keys:\n self.feature_store[d2m_to_datacomp_keys[k]].append(v)\n else:\n self.feature_store[k].append(v)",
"score": 51.314279700546656
},
{
"filename": "dataset2metadata/dataloaders.py",
"retrieved_chunk": " for i, model_class in enumerate(wrapper_classes):\n assert len(model_class.preprocessors) == len(model_class.raw_inputs)\n preprocess_directives = [\n (model_class.raw_inputs[k], model_class.preprocessors[k]) for k in range(len(model_class.preprocessors))\n ]\n input_map[models[i]] = []\n for j in range(len(preprocess_directives)):\n if preprocess_directives[j] not in unique_derectives:\n input_map[models[i]].append(len(unique_derectives))\n unique_derectives.append(preprocess_directives[j])",
"score": 49.82131789020736
}
] | python | write(yml['output_metadata_dir']) |
|
from omegaconf import OmegaConf
import torch
from torch.optim.lr_scheduler import MultiStepLR
from ..models.gnn_ssl import GnnSslNet
from ..metrics import Loss
from .base import BaseTrainer
class GnnSslNetTrainer(BaseTrainer):
"""This class abstracts the
training/validation/testing procedures
used for training a GnnSslNet
"""
def __init__(self, config):
super().__init__(config)
self.rmse = Loss(config["targets"], mode="l2", dim=1)
def _step(self, batch, batch_idx, log_model_output=False, log_labels=False):
"""This is the base step done on every training, validation and testing batch iteration.
This had to be overriden since we are using multiple datasets
"""
loss_vectors = []
outputs = []
targets = []
n_mics = []
# Loop for every microphone number
for (x, y) in batch:
n = x["signal"].shape[1]
# 1. Compute model output and loss
output = self.model(x)
loss = self. | loss(output, y, mean_reduce=False) |
outputs.append(output)
targets.append(y)
loss_vectors.append(loss)
n_mics.append(n)
# 2. RMSE
rmse_error = self.rmse(output, y, mean_reduce=True)
self.log(f"rmse_{n}_mics", rmse_error, on_step=True, prog_bar=False, on_epoch=False)
output_dict = {}
for i, n in enumerate(n_mics):
loss_vector = loss_vectors[i]
mean_loss = loss_vector.mean()
output_dict[f"loss_vector_{n}"] = loss_vector.detach().cpu()
output_dict[f"mean_loss_{n}"] = mean_loss.detach().cpu()
# TODO: Add these to a callback
# 2. Log model output
if log_model_output:
output_dict[f"model_outputs_{n}"] = outputs[i]
output_dict["loss"] = torch.stack(loss_vectors).mean()
return output_dict
| gnn_ssl/trainers/gnn_ssl.py | egrinstein-gnn_ssl-74c7b5a | [
{
"filename": "gnn_ssl/trainers/base.py",
"retrieved_chunk": " def forward(self, x):\n return self.model(x)\n def _step(self, batch, batch_idx, epoch_type):\n x, y = batch[0] # 0 is to ignore the microphone array index\n # 1. Compute model output and loss\n x = self.forward(x)\n loss = self.loss(x, y, mean_reduce=True)\n self.log_dict({f\"{epoch_type}_loss_step\": loss})\n return {\n \"loss\": loss",
"score": 60.00642399223847
},
{
"filename": "visualize_outputs.py",
"retrieved_chunk": " # 3. Load loss function\n loss = get_class(config[\"targets\"][\"loss_class\"])(config[\"targets\"])\n # Compute outputs for a single batch\n x, y = batch = next(iter(dataset_test))[0]\n model_outputs = {\n model_name: model[\"model\"](x)\n for model_name, model in models.items()\n }\n create_visualizations(model_outputs, y, loss, plot_target=False)\nif __name__ == \"__main__\":",
"score": 49.3485986293205
},
{
"filename": "gnn_ssl/metrics.py",
"retrieved_chunk": " # Compute loss\n loss = self.loss(model_output, targets)\n if self.weighted:\n loss *= targets\n if mean_reduce:\n if self.weighted:\n loss = loss.sum()/loss.shape[0]\n else:\n loss = loss.mean()\n return loss",
"score": 38.56377851259966
},
{
"filename": "gnn_ssl/metrics.py",
"retrieved_chunk": "class ExampleLoss(torch.nn.Module):\n def __init__(self, config):\n super().__init__()\n self.config = config\n def forward(self, model_output, targets, mean_reduce=True):\n x = model_output[\"example_output\"]\n # Don't do anything with targets, just return the output\n if mean_reduce:\n x = x.mean()\n return x",
"score": 29.51359630143259
},
{
"filename": "gnn_ssl/trainers/base.py",
"retrieved_chunk": " model, training = config[\"model\"], config[\"training\"]\n features, targets = config[\"features\"], config[\"targets\"]\n self.model = get_class(model[\"class\"])(model)\n # self.feature_extractor = get_class(features[\"class\"])(features)\n self.loss = get_class(targets[\"loss_class\"])(targets)\n self.model_config = model\n self.features_config = features\n self.targets_config = targets\n self.training_config = training\n self.log_step = self.training_config[\"log_step\"]",
"score": 25.105159510428983
}
] | python | loss(output, y, mean_reduce=False) |
import torch
from pysoundloc.pysoundloc.utils.math import grid_argmax
from .pairwise_neural_srp import PairwiseNeuralSrp
from ..feature_extractors.metadata import filter_local_metadata
class NeuralSrp(PairwiseNeuralSrp):
"""Multi-microphone version of PairwiseNeuralSrp,
which works for a single pair of microphones.
NeuralSrp computes a PairwiseNeuralSrp grid for each microphone pair,
then sums them together.
"""
def __init__(self, config):
super().__init__(config)
def forward(self, x, estimate_coords=True, mean=True):
# x = self.feature_extractor(x) TODO: Extract features before for efficiency
# batch_size, n_channels, n_time_bins, n_freq_bins = x["signal"].shape
batch_size, n_channels, n_time_samples = x["signal"].shape
room_dims = x["metadata"]["global"]["room_dims"][:, :2]
y = []
n_pairs = n_channels*(n_channels - 1)/2
for i in range(n_channels):
for j in range(i + 1, n_channels):
x_ij = {
"signal": x["signal"][:, [i, j]],
"metadata": filter_local_metadata(x["metadata"], [i, j])
}
y.append(super(). | forward(x_ij)["grid"]) |
#count += 1
y = torch.stack(y, dim=1).sum(dim=1)
if mean:
y /= n_pairs
if estimate_coords:
estimated_coords = grid_argmax(y, room_dims)
return {
"source_coordinates": estimated_coords,
"grid": y
}
return y
| gnn_ssl/models/neural_srp.py | egrinstein-gnn_ssl-74c7b5a | [
{
"filename": "gnn_ssl/models/base/base_relation_network.py",
"retrieved_chunk": " # TODO: parallelize this?\n pairwise_relations = []\n for i in range(n_channels):\n for j in range(i + 1, n_channels):\n x_ij = self.on_start_hook(x, i, j)\n pairwise_relation = self.pairwise_relation_network(x_ij)#*x_ij[:, :625]\n # if self.mask:\n # pairwise_relation *= x_ij[:, :pairwise_relation.shape[1]]\n pairwise_relations.append(pairwise_relation)\n pairwise_relations = torch.stack(pairwise_relations, dim=1)",
"score": 71.14620954585538
},
{
"filename": "gnn_ssl/feature_extractors/stft.py",
"retrieved_chunk": " \"Expected input has shape (batch_size, n_channels, time_steps)\"\n batch_size, n_channels, time_steps = X.shape\n stfts = super().forward(X)\n # (batch_size, n_channels, n_time_bins, n_freq_bins)\n y = []\n # Compute the cross-spectrum between each pair of channels\n for i in range(n_channels):\n for j in range(i + 1, n_channels):\n y_ij = stfts[:, i]*stfts[:, j].conj()\n y.append(y_ij)",
"score": 67.14098860144546
},
{
"filename": "gnn_ssl/feature_extractors/pairwise_feature_extractors.py",
"retrieved_chunk": " if self.pairwise_feature_extractor is not None:\n x_ij = self.pairwise_feature_extractor(x, i, j)\n else:\n x_ij = torch.cat([x[\"signal\"][:, i], x[\"signal\"][:, j]], dim=1)\n if not self.is_metadata_aware:\n return x_ij\n # 2. Concatenate local metadata\n mic_coords = x[\"local\"][\"mic_coordinates\"]\n room_dims = x[\"global\"][\"room_dims\"]\n x_ij = torch.cat([",
"score": 50.22696164874142
},
{
"filename": "gnn_ssl/feature_extractors/pairwise_feature_extractors.py",
"retrieved_chunk": " for j in range(i + 1, n_array):\n grid_ij = compute_pairwise_srp_grids(\n x_signal[:, k, i], x_signal[:, k, j], self.sr,\n mic_coords[:, k, i], mic_coords[:, k, j],\n room_dims, n_grid_points=self.n_grid_points,\n n_correlation_neighbours=self.thickness\n )\n grids[:, k] += grid_ij\n if self.flatten:\n grids = grids.flatten(start_dim=2)",
"score": 38.5311018809255
},
{
"filename": "gnn_ssl/feature_extractors/pairwise_feature_extractors.py",
"retrieved_chunk": " self.flatten = flatten\n self.normalize = normalize\n if flatten:\n self.n_output = n_grid_points**2\n else:\n self.n_output = (n_grid_points, n_grid_points)\n def forward(self, x, i, j):\n x_i = x[\"signal\"][:, i]\n x_j = x[\"signal\"][:, j]\n mic_i_coords = x[\"local\"][\"mic_coordinates\"][:, i]",
"score": 37.67927210714838
}
] | python | forward(x_ij)["grid"]) |
from gnn_ssl.metrics import NormLoss
from .base import BaseTrainer
class NeuralSrpTrainer(BaseTrainer):
def __init__(self, config):
super().__init__(config)
self.norm = NormLoss("l2")
def _step(self, batch, batch_idx, epoch_type):
x, y = batch[0] # 0 is because the current dataloader is multi-microphone
if self.targets_config["type"] == "source_coordinates":
n_output_coords = self.targets_config["n_output_coordinates"]
y["source_coordinates"] = y["source_coordinates"][:, 0, :n_output_coords] # Only select first source
return super(). | _step((x, y), batch_idx, epoch_type) | gnn_ssl/trainers/neural_srp.py | egrinstein-gnn_ssl-74c7b5a | [
{
"filename": "gnn_ssl/trainers/base.py",
"retrieved_chunk": " def forward(self, x):\n return self.model(x)\n def _step(self, batch, batch_idx, epoch_type):\n x, y = batch[0] # 0 is to ignore the microphone array index\n # 1. Compute model output and loss\n x = self.forward(x)\n loss = self.loss(x, y, mean_reduce=True)\n self.log_dict({f\"{epoch_type}_loss_step\": loss})\n return {\n \"loss\": loss",
"score": 68.95802668968425
},
{
"filename": "gnn_ssl/trainers/base.py",
"retrieved_chunk": " }\n def training_step(self, batch, batch_idx):\n return self._step(batch, batch_idx, \"train\")\n def validation_step(self, batch, batch_idx):\n return self._step(batch, batch_idx, \"validation\")\n def test_step(self, batch, batch_idx):\n return self._step(batch, batch_idx, \"test\")\n def _epoch_end(self, outputs, epoch_type=\"train\"):\n # 1. Compute epoch metrics\n outputs = _merge_list_of_dicts(outputs)",
"score": 58.41526864178726
},
{
"filename": "gnn_ssl/datasets/distributed_ssl.py",
"retrieved_chunk": " if len(y[\"mic_coordinates\"].shape) == 3:\n # Array\n y[\"mic_coordinates\"] = y[\"mic_coordinates\"][0]\n if len(y[\"source_coordinates\"].shape) == 1:\n # Expand to multi-source\n y[\"source_coordinates\"] = y[\"source_coordinates\"].unsqueeze(0)\n y = {\n \"source_coordinates\": y[\"source_coordinates\"],\n \"mic_coordinates\": y[\"mic_coordinates\"],\n \"room_dims\": y[\"room_dims\"],",
"score": 49.862461048054776
},
{
"filename": "gnn_ssl/trainers/gnn_ssl.py",
"retrieved_chunk": " \"\"\"\n def __init__(self, config):\n super().__init__(config)\n self.rmse = Loss(config[\"targets\"], mode=\"l2\", dim=1)\n def _step(self, batch, batch_idx, log_model_output=False, log_labels=False):\n \"\"\"This is the base step done on every training, validation and testing batch iteration.\n This had to be overriden since we are using multiple datasets\n \"\"\"\n loss_vectors = []\n outputs = []",
"score": 46.07373339230438
},
{
"filename": "gnn_ssl/models/di_nn.py",
"retrieved_chunk": " self.metadata_dim = dataset_config[\"metadata_dim\"]\n self.grid_size = targets_config[\"n_points_per_axis\"]\n self.output_type = targets_config[\"type\"] # grid or regression vector\n if self.output_type == \"source_coordinates\":\n config[\"encoder_mlp_config\"][\"n_output_channels\"] = targets_config[\"n_output_coordinates\"]\n # 3. Create encoder\n self.encoder = Encoder(self.n_input_channels,\n self.input_shape,\n config[\"conv_layers_config\"],\n config[\"rnn_config\"],",
"score": 41.691329780606154
}
] | python | _step((x, y), batch_idx, epoch_type) |
|
import torch
import torchvision.transforms as T
from embed import Pipeline
from transformers import AutoFeatureExtractor
MODEL_NAME = "nateraw/vit-base-beans"
EXTRACTOR = AutoFeatureExtractor.from_pretrained(MODEL_NAME)
# Data transformation chain.
TRANSFORM_CHAIN = T.Compose(
[
# We first resize the input image to 256x256 and then we take center crop.
T.Resize(int((256 / 224) * EXTRACTOR.size["height"])),
T.CenterCrop(EXTRACTOR.size["height"]),
T.ToTensor(),
T.Normalize(mean=EXTRACTOR.image_mean, std=EXTRACTOR.image_std),
]
)
# Here, we map embedding extraction utility on our subset of candidate images.
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
pl = Pipeline(MODEL_NAME)
pl.huggingface_input("beans", "train")
pl. | batch(length=10) |
pl.embed_image(DEVICE, TRANSFORM_CHAIN)
pl.sqlite_vector_output()
| examples/image_embed.py | bytewax-rt-embed-7069fc6 | [
{
"filename": "examples/video_transcribe.py",
"retrieved_chunk": "from pydub import AudioSegment\nimport torch\nlogging.basicConfig(level=logging.INFO)\nDEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\nmodel = whisper.load_model(\"base\")\nprint(DEVICE)\nclass YouTubeInput(PartitionedInput):\n def __init__(self, urls: list, audio_only: bool = True):\n self.urls = urls\n self.audio_only = audio_only",
"score": 32.13998429122145
},
{
"filename": "examples/csv_input.py",
"retrieved_chunk": "from embed import Pipeline\npl = Pipeline(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\npl.csv_input(\"data/books.csv\")\npl.make_document(group_key=\"header1\", text=\"header2\")\npl.embed_document()\n# pl.pg_vector_output(\"test_collection\", vector_size=512)\npl.stdout()\npl.run()",
"score": 23.90136844076149
},
{
"filename": "examples/hn_embed.py",
"retrieved_chunk": "from embed import Pipeline\npl = Pipeline(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\npl.hacker_news(poll_frequency=None)\npl.parse_html()\npl.embed_document()\npl.qdrant_output(collection=\"test_collection\", vector_size=384)\npl.run(workers=8)",
"score": 23.79283248018309
},
{
"filename": "examples/sqlalchemy.py",
"retrieved_chunk": " def close(self):\n pass\npl = Pipeline()\npl.make_document(\"group_key\", \"text\")\nflow = Dataflow()\nflow.input(\n \"schema_data\", SQLAlchemyInput([\"postgresql://user:password@localhost/mydatabase\"])\n)\nflow.make_document(\n lambda table_data: Document(",
"score": 18.16564296399462
},
{
"filename": "src/embed/embedding/huggingface.py",
"retrieved_chunk": "def get_image_inputs(batch, transformation_chain, device):\n \"\"\"\n Get image model inputs\n \"\"\"\n images = [image_data[\"image\"] for image_data in batch]\n image_batch_transformed = torch.stack(\n [transformation_chain(image) for image in images]\n )\n return {\"pixel_values\": image_batch_transformed.to(device)}\ndef hf_document_embed(document: Document, tokenizer, model, length=512):",
"score": 15.341558917342386
}
] | python | batch(length=10) |
# from bytewax.dataflow import Dataflow
from bytewax.inputs import PartitionedInput, StatefulSource
from sqlalchemy import create_engine, inspect
from embed.objects.base import Document
from embed.embedding.huggingface import hf_document_embed
from embed.stores.qdrant import QdrantOutput
from embed.processing.batch import Dataflow, Pipeline
from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
class SQLAlchemyInput(PartitionedInput):
def __init__(self, connection_strings: list):
self.urls = connection_strings
def list_parts(self):
# return the set of urls to be divided internally
return set(self.connection_strings)
def build_part(self, part_connection_string, resume_state):
assert resume_state is None
return _SQLAlchemySource(part_connection_string)
class _SQLAlchemySource(StatefulSource):
def __init__(self, connection_string):
engine = create_engine(connection_string)
# create inspector
self.inspector = inspect(engine)
schemas = self.inspector.get_schemas_names()
schema__tables = []
for schema in schemas:
table_names = self.inspector.get_table_names(schema=schema)
for table in table_names:
schema__tables.append((schema, table))
self.schema__tables = iter(schema__tables)
def next(self):
schema, table = next(self.schema__tables)
table_representation = ""
# Get columns
columns = self.inspector.get_columns(table, schema=schema)
(
table_representation
+ "Columns:"
+ " ,".join(
[f" - {column['name']} ({column['type']})" for column in columns]
)
)
# Get foreign keys
fks = self.inspector.get_foreign_keys(table, schema=schema)
(
table_representation
+ "Foreign keys:"
+ " ,".join([f"{fk['name']}" for fk in fks])
)
comments = self.inspector. | get_table_comment(table, schema=schema) |
table_representation + f"{comments}"
return {
"key": f"{schema}+{table}",
"schema": schema,
"table_name": table,
"text": table_representation,
}
def snapshot(self):
pass
def close(self):
pass
pl = Pipeline()
pl.make_document("group_key", "text")
flow = Dataflow()
flow.input(
"schema_data", SQLAlchemyInput(["postgresql://user:password@localhost/mydatabase"])
)
flow.make_document(
lambda table_data: Document(
key="key", text="text", metadata=table_data
)
)
flow.map(lambda doc: hf_document_embed(doc, tokenizer, model, length=512))
flow.output("output", QdrantOutput(collection_name="test_collection", vector_size=512))
| examples/sqlalchemy.py | bytewax-rt-embed-7069fc6 | [
{
"filename": "src/embed/stores/qdrant.py",
"retrieved_chunk": " ),\n schema=self.schema,\n )\n def build(self, worker_index, worker_count):\n return _QdrantVectorSink(self.client, self.collection_name)",
"score": 26.906908318310258
},
{
"filename": "src/embed/stores/qdrant.py",
"retrieved_chunk": " self.vector_size = vector_size\n self.schema = schema\n self.client = QdrantClient(host, port=6333)\n try:\n self.client.get_collection(collection_name=\"test_collection\")\n except UnexpectedResponse:\n self.client.recreate_collection(\n collection_name=\"test_collection\",\n vectors_config=VectorParams(\n size=self.vector_size, distance=Distance.COSINE",
"score": 22.652485407159347
},
{
"filename": "src/embed/stores/qdrant.py",
"retrieved_chunk": "class QdrantOutput(DynamicOutput):\n \"\"\"Qdrant.\n Workers are the unit of parallelism.\n Can support at-least-once processing. Messages from the resume\n epoch will be duplicated right after resume.\n \"\"\"\n def __init__(\n self, collection_name, vector_size, schema=\"\", host=\"localhost\", port=6333\n ):\n self.collection_name = collection_name",
"score": 14.703738677106143
},
{
"filename": "src/embed/objects/webpage.py",
"retrieved_chunk": " def parse_html(self, tokenizer):\n elements = partition_html(text=self.html)\n elements = [x for x in elements if x.to_dict()[\"type\"] == \"NarrativeText\"]\n elements = \" \".join([f\"{x}\" for x in elements])\n self.content = clean_non_ascii_chars(replace_unicode_quotes(clean(elements)))\n self.text += chunk_by_attention_window(self.content, tokenizer)\n try:\n self.group_key = hashlib.md5(self.content[:2000].encode()).hexdigest()\n except AttributeError:\n self.group_key = hashlib.md5(self.content[:2000]).hexdigest()",
"score": 11.925290236526878
},
{
"filename": "src/embed/objects/webpage.py",
"retrieved_chunk": " except RequestException as e:\n print(f\"Request failed (attempt {i + 1}/{self.max_retries}): {e}\")\n if i == self.max_retries:\n print(f\"skipping url {self.url}\")\n self.html = \"\"\n break\n print(f\"Retrying in {self.wait_time} seconds...\")\n time.sleep(self.wait_time)\n i += 1\n # Clean the code and setup the dataclass",
"score": 8.12840537798003
}
] | python | get_table_comment(table, schema=schema) |
# from bytewax.dataflow import Dataflow
from bytewax.inputs import PartitionedInput, StatefulSource
from sqlalchemy import create_engine, inspect
from embed.objects.base import Document
from embed.embedding.huggingface import hf_document_embed
from embed.stores.qdrant import QdrantOutput
from embed.processing.batch import Dataflow, Pipeline
from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
class SQLAlchemyInput(PartitionedInput):
def __init__(self, connection_strings: list):
self.urls = connection_strings
def list_parts(self):
# return the set of urls to be divided internally
return set(self.connection_strings)
def build_part(self, part_connection_string, resume_state):
assert resume_state is None
return _SQLAlchemySource(part_connection_string)
class _SQLAlchemySource(StatefulSource):
def __init__(self, connection_string):
engine = create_engine(connection_string)
# create inspector
self.inspector = inspect(engine)
schemas = self.inspector. | get_schemas_names() |
schema__tables = []
for schema in schemas:
table_names = self.inspector.get_table_names(schema=schema)
for table in table_names:
schema__tables.append((schema, table))
self.schema__tables = iter(schema__tables)
def next(self):
schema, table = next(self.schema__tables)
table_representation = ""
# Get columns
columns = self.inspector.get_columns(table, schema=schema)
(
table_representation
+ "Columns:"
+ " ,".join(
[f" - {column['name']} ({column['type']})" for column in columns]
)
)
# Get foreign keys
fks = self.inspector.get_foreign_keys(table, schema=schema)
(
table_representation
+ "Foreign keys:"
+ " ,".join([f"{fk['name']}" for fk in fks])
)
comments = self.inspector.get_table_comment(table, schema=schema)
table_representation + f"{comments}"
return {
"key": f"{schema}+{table}",
"schema": schema,
"table_name": table,
"text": table_representation,
}
def snapshot(self):
pass
def close(self):
pass
pl = Pipeline()
pl.make_document("group_key", "text")
flow = Dataflow()
flow.input(
"schema_data", SQLAlchemyInput(["postgresql://user:password@localhost/mydatabase"])
)
flow.make_document(
lambda table_data: Document(
key="key", text="text", metadata=table_data
)
)
flow.map(lambda doc: hf_document_embed(doc, tokenizer, model, length=512))
flow.output("output", QdrantOutput(collection_name="test_collection", vector_size=512))
| examples/sqlalchemy.py | bytewax-rt-embed-7069fc6 | [
{
"filename": "examples/video_transcribe.py",
"retrieved_chunk": " def list_parts(self):\n # return the set of urls to be divided internally\n return set(self.urls)\n def build_part(self, part_url, resume_state):\n assert resume_state is None\n return _YouTubeSource(part_url, self.audio_only)\nclass _YouTubeSource(StatefulSource):\n def __init__(self, yt_url, audio_only):\n # TODO: check for ffmpeg\n self.complete = False",
"score": 28.636470909542467
},
{
"filename": "src/embed/sources/file.py",
"retrieved_chunk": "# self.batch_size = batch_size\n# def list_parts(self):\n# return {\"single-part\"}\n# def build_part(self, for_key, resume_state):\n# assert for_key == \"single-part\"\n# assert resume_state is None\n# return(_HuggingfaceStreamingDatasetSource(self.dataset_name, self.split_part, self.batch_size))",
"score": 28.1591783377093
},
{
"filename": "src/embed/sources/file.py",
"retrieved_chunk": " def build_part(self, for_key, resume_state):\n assert for_key == \"single-part\"\n assert resume_state is None\n return _HuggingfaceStreamingDatasetSource(self.dataset_name, self.split_part)\n# TODO: Huggingface Dataset Source Chunks\n# Should take a part of a dataset per\n# worker and pass the chunk downstream\n# class _HuggingfaceDatasetSource(StatefulSource):\n# def __init__(self, dataset_name, split_part, batch_size):\n# self.batch_size = batch_size",
"score": 27.578412111339105
},
{
"filename": "examples/push_api.py",
"retrieved_chunk": " assert for_key == \"single-part\"\n assert resume_state is None\n return _PushSource(self.endpoint, self.host, self.port)\nclass _PushSource(StatefulSource):\n def __init__(self, endpoint, host, port):\n self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n self.server_socket.bind((host, port))\n self.server_socket.listen(1)\n logging.info(\"Listening on port %s ...\", port)",
"score": 21.983616738697172
},
{
"filename": "examples/push_api.py",
"retrieved_chunk": " self.error_code = code\n self.error_message = message\nclass PushInput(PartitionedInput):\n def __init__(self, endpoint: str, port: int = 8000, host: str = \"0.0.0.0\"):\n self.endpoint = endpoint\n self.host = host\n self.port = port\n def list_parts(self):\n return {\"single-part\"}\n def build_part(self, for_key, resume_state):",
"score": 19.896062884551714
}
] | python | get_schemas_names() |
import time
import requests
import hashlib
from typing import Optional
from fake_useragent import UserAgent
from requests.exceptions import RequestException
from unstructured.partition.html import partition_html
from unstructured.cleaners.core import (
clean,
replace_unicode_quotes,
clean_non_ascii_chars,
)
from unstructured.staging.huggingface import chunk_by_attention_window
from .base import Document
class WebPage(Document):
url: str
html: Optional[str]
content: Optional[str]
headers: Optional[dict] = None
max_retries: int = 3
wait_time: int = 1
def __str__(self):
return f"WebPage('{self.url}')"
def get_page(self):
if self.headers is None:
# make a user agent
ua = UserAgent()
accept = [
"text/html",
"application/xhtml+xml",
"application/xml;q=0.9",
"image/webp",
"*/*;q=0.8",
]
self.headers = {
"User-Agent": ua.random,
"Accept": ",".join(accept),
"Accept-Language": "en-US,en;q=0.5",
"Referrer": "https://www.google.com/",
"DNT": "1",
"Connection": "keep-alive",
"Upgrade-Insecure-Requests": "1",
}
# Send the initial request
for i in range(self.max_retries):
try:
response = requests.get(self.url, headers=self.headers)
response.raise_for_status()
self.html = response.content
break
except RequestException as e:
print(f"Request failed (attempt {i + 1}/{self.max_retries}): {e}")
if i == self.max_retries:
print(f"skipping url {self.url}")
self.html = ""
break
print(f"Retrying in {self.wait_time} seconds...")
time.sleep(self.wait_time)
i += 1
# Clean the code and setup the dataclass
def parse_html(self, tokenizer):
elements = partition_html(text=self.html)
elements = [x for x in elements if x.to_dict()["type"] == "NarrativeText"]
elements = " ".join([f"{x}" for x in elements])
self.content = clean_non_ascii_chars(replace_unicode_quotes(clean(elements)))
self. | text += chunk_by_attention_window(self.content, tokenizer) |
try:
self.group_key = hashlib.md5(self.content[:2000].encode()).hexdigest()
except AttributeError:
self.group_key = hashlib.md5(self.content[:2000]).hexdigest()
return self
| src/embed/objects/webpage.py | bytewax-rt-embed-7069fc6 | [
{
"filename": "src/embed/__init__.py",
"retrieved_chunk": " \"http_input\",\n HTTPInput(urls=urls, poll_frequency=poll_frequency, max_retries=1),\n )\n self.flat_map(lambda x: x)\n return self\n def hacker_news(self, poll_frequency=300):\n \"\"\"\n Parse hackernews homepage, emits Documents with the linked urls content.\n \"\"\"\n self.http_input(",
"score": 39.29037487662524
},
{
"filename": "src/embed/__init__.py",
"retrieved_chunk": " return None\n self.filter_map(fetch)\n self.redistribute()\n return self\n def make_document(self, group_key=None, metadata=None, text=None, embeddings=None):\n \"\"\"\n Takes a `metadata` dict, and builds a Document.\n \"\"\"\n self.map(lambda x: Document(group_key=x[group_key], text=x[text], metadata=x))\n return self",
"score": 38.676994174809835
},
{
"filename": "src/embed/__init__.py",
"retrieved_chunk": " HuggingfaceDatasetStreamingInput(dataset_name, split_part),\n )\n ##\n # Processing\n ##\n def parse_html(self):\n \"\"\"\n TODO\n \"\"\"\n self.map(lambda x: x.parse_html(self.get_tokenizer()))",
"score": 37.011999176866
},
{
"filename": "src/embed/processing/text.py",
"retrieved_chunk": "from unstructured.staging.huggingface import chunk_by_attention_window\n# chunk the news article and summary\ndef chunk(text, tokenizer):\n chunks = []\n for chunk in text:\n chunks += chunk_by_attention_window(text, tokenizer)\n return chunks",
"score": 34.81891835014308
},
{
"filename": "src/embed/__init__.py",
"retrieved_chunk": " return self\n def embed_document(self):\n \"\"\"\n TODO\n \"\"\"\n self.map(\n lambda x: hf_document_embed(\n x, self.get_tokenizer(), self.get_model(), length=512\n )\n )",
"score": 31.236369906889237
}
] | python | text += chunk_by_attention_window(self.content, tokenizer) |
import torch
import torchvision.transforms as T
from embed import Pipeline
from transformers import AutoFeatureExtractor
MODEL_NAME = "nateraw/vit-base-beans"
EXTRACTOR = AutoFeatureExtractor.from_pretrained(MODEL_NAME)
# Data transformation chain.
TRANSFORM_CHAIN = T.Compose(
[
# We first resize the input image to 256x256 and then we take center crop.
T.Resize(int((256 / 224) * EXTRACTOR.size["height"])),
T.CenterCrop(EXTRACTOR.size["height"]),
T.ToTensor(),
T.Normalize(mean=EXTRACTOR.image_mean, std=EXTRACTOR.image_std),
]
)
# Here, we map embedding extraction utility on our subset of candidate images.
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
pl = Pipeline(MODEL_NAME)
pl.huggingface_input("beans", "train")
pl.batch(length=10)
pl.embed_image(DEVICE, TRANSFORM_CHAIN)
pl. | sqlite_vector_output() | examples/image_embed.py | bytewax-rt-embed-7069fc6 | [
{
"filename": "examples/video_transcribe.py",
"retrieved_chunk": "from pydub import AudioSegment\nimport torch\nlogging.basicConfig(level=logging.INFO)\nDEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\nmodel = whisper.load_model(\"base\")\nprint(DEVICE)\nclass YouTubeInput(PartitionedInput):\n def __init__(self, urls: list, audio_only: bool = True):\n self.urls = urls\n self.audio_only = audio_only",
"score": 37.73924277796745
},
{
"filename": "examples/csv_input.py",
"retrieved_chunk": "from embed import Pipeline\npl = Pipeline(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\npl.csv_input(\"data/books.csv\")\npl.make_document(group_key=\"header1\", text=\"header2\")\npl.embed_document()\n# pl.pg_vector_output(\"test_collection\", vector_size=512)\npl.stdout()\npl.run()",
"score": 37.57332568778929
},
{
"filename": "examples/hn_embed.py",
"retrieved_chunk": "from embed import Pipeline\npl = Pipeline(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\npl.hacker_news(poll_frequency=None)\npl.parse_html()\npl.embed_document()\npl.qdrant_output(collection=\"test_collection\", vector_size=384)\npl.run(workers=8)",
"score": 37.305228473733
},
{
"filename": "examples/sqlalchemy.py",
"retrieved_chunk": " def close(self):\n pass\npl = Pipeline()\npl.make_document(\"group_key\", \"text\")\nflow = Dataflow()\nflow.input(\n \"schema_data\", SQLAlchemyInput([\"postgresql://user:password@localhost/mydatabase\"])\n)\nflow.make_document(\n lambda table_data: Document(",
"score": 28.486795085826998
},
{
"filename": "src/embed/embedding/huggingface.py",
"retrieved_chunk": "def get_image_inputs(batch, transformation_chain, device):\n \"\"\"\n Get image model inputs\n \"\"\"\n images = [image_data[\"image\"] for image_data in batch]\n image_batch_transformed = torch.stack(\n [transformation_chain(image) for image in images]\n )\n return {\"pixel_values\": image_batch_transformed.to(device)}\ndef hf_document_embed(document: Document, tokenizer, model, length=512):",
"score": 15.341558917342386
}
] | python | sqlite_vector_output() |
|
# from bytewax.dataflow import Dataflow
from bytewax.inputs import PartitionedInput, StatefulSource
from sqlalchemy import create_engine, inspect
from embed.objects.base import Document
from embed.embedding.huggingface import hf_document_embed
from embed.stores.qdrant import QdrantOutput
from embed.processing.batch import Dataflow, Pipeline
from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
class SQLAlchemyInput(PartitionedInput):
def __init__(self, connection_strings: list):
self.urls = connection_strings
def list_parts(self):
# return the set of urls to be divided internally
return set(self.connection_strings)
def build_part(self, part_connection_string, resume_state):
assert resume_state is None
return _SQLAlchemySource(part_connection_string)
class _SQLAlchemySource(StatefulSource):
def __init__(self, connection_string):
engine = create_engine(connection_string)
# create inspector
self.inspector = inspect(engine)
schemas = self.inspector.get_schemas_names()
schema__tables = []
for schema in schemas:
table_names = self.inspector. | get_table_names(schema=schema) |
for table in table_names:
schema__tables.append((schema, table))
self.schema__tables = iter(schema__tables)
def next(self):
schema, table = next(self.schema__tables)
table_representation = ""
# Get columns
columns = self.inspector.get_columns(table, schema=schema)
(
table_representation
+ "Columns:"
+ " ,".join(
[f" - {column['name']} ({column['type']})" for column in columns]
)
)
# Get foreign keys
fks = self.inspector.get_foreign_keys(table, schema=schema)
(
table_representation
+ "Foreign keys:"
+ " ,".join([f"{fk['name']}" for fk in fks])
)
comments = self.inspector.get_table_comment(table, schema=schema)
table_representation + f"{comments}"
return {
"key": f"{schema}+{table}",
"schema": schema,
"table_name": table,
"text": table_representation,
}
def snapshot(self):
pass
def close(self):
pass
pl = Pipeline()
pl.make_document("group_key", "text")
flow = Dataflow()
flow.input(
"schema_data", SQLAlchemyInput(["postgresql://user:password@localhost/mydatabase"])
)
flow.make_document(
lambda table_data: Document(
key="key", text="text", metadata=table_data
)
)
flow.map(lambda doc: hf_document_embed(doc, tokenizer, model, length=512))
flow.output("output", QdrantOutput(collection_name="test_collection", vector_size=512))
| examples/sqlalchemy.py | bytewax-rt-embed-7069fc6 | [
{
"filename": "src/embed/stores/qdrant.py",
"retrieved_chunk": " ),\n schema=self.schema,\n )\n def build(self, worker_index, worker_count):\n return _QdrantVectorSink(self.client, self.collection_name)",
"score": 26.146471414612765
},
{
"filename": "src/embed/stores/qdrant.py",
"retrieved_chunk": " self.vector_size = vector_size\n self.schema = schema\n self.client = QdrantClient(host, port=6333)\n try:\n self.client.get_collection(collection_name=\"test_collection\")\n except UnexpectedResponse:\n self.client.recreate_collection(\n collection_name=\"test_collection\",\n vectors_config=VectorParams(\n size=self.vector_size, distance=Distance.COSINE",
"score": 21.5811929812738
},
{
"filename": "src/embed/stores/qdrant.py",
"retrieved_chunk": "class QdrantOutput(DynamicOutput):\n \"\"\"Qdrant.\n Workers are the unit of parallelism.\n Can support at-least-once processing. Messages from the resume\n epoch will be duplicated right after resume.\n \"\"\"\n def __init__(\n self, collection_name, vector_size, schema=\"\", host=\"localhost\", port=6333\n ):\n self.collection_name = collection_name",
"score": 17.37949355978847
},
{
"filename": "examples/video_transcribe.py",
"retrieved_chunk": " def list_parts(self):\n # return the set of urls to be divided internally\n return set(self.urls)\n def build_part(self, part_url, resume_state):\n assert resume_state is None\n return _YouTubeSource(part_url, self.audio_only)\nclass _YouTubeSource(StatefulSource):\n def __init__(self, yt_url, audio_only):\n # TODO: check for ffmpeg\n self.complete = False",
"score": 14.49839109139229
},
{
"filename": "src/embed/objects/webpage.py",
"retrieved_chunk": " def parse_html(self, tokenizer):\n elements = partition_html(text=self.html)\n elements = [x for x in elements if x.to_dict()[\"type\"] == \"NarrativeText\"]\n elements = \" \".join([f\"{x}\" for x in elements])\n self.content = clean_non_ascii_chars(replace_unicode_quotes(clean(elements)))\n self.text += chunk_by_attention_window(self.content, tokenizer)\n try:\n self.group_key = hashlib.md5(self.content[:2000].encode()).hexdigest()\n except AttributeError:\n self.group_key = hashlib.md5(self.content[:2000]).hexdigest()",
"score": 11.856934452154254
}
] | python | get_table_names(schema=schema) |
# from bytewax.dataflow import Dataflow
from bytewax.inputs import PartitionedInput, StatefulSource
from sqlalchemy import create_engine, inspect
from embed.objects.base import Document
from embed.embedding.huggingface import hf_document_embed
from embed.stores.qdrant import QdrantOutput
from embed.processing.batch import Dataflow, Pipeline
from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
class SQLAlchemyInput(PartitionedInput):
def __init__(self, connection_strings: list):
self.urls = connection_strings
def list_parts(self):
# return the set of urls to be divided internally
return set(self.connection_strings)
def build_part(self, part_connection_string, resume_state):
assert resume_state is None
return _SQLAlchemySource(part_connection_string)
class _SQLAlchemySource(StatefulSource):
def __init__(self, connection_string):
engine = create_engine(connection_string)
# create inspector
self.inspector = inspect(engine)
schemas = self.inspector.get_schemas_names()
schema__tables = []
for schema in schemas:
table_names = self.inspector.get_table_names(schema=schema)
for table in table_names:
schema__tables.append((schema, table))
self.schema__tables = iter(schema__tables)
def next(self):
schema, table = next(self.schema__tables)
table_representation = ""
# Get columns
columns = self.inspector. | get_columns(table, schema=schema) |
(
table_representation
+ "Columns:"
+ " ,".join(
[f" - {column['name']} ({column['type']})" for column in columns]
)
)
# Get foreign keys
fks = self.inspector.get_foreign_keys(table, schema=schema)
(
table_representation
+ "Foreign keys:"
+ " ,".join([f"{fk['name']}" for fk in fks])
)
comments = self.inspector.get_table_comment(table, schema=schema)
table_representation + f"{comments}"
return {
"key": f"{schema}+{table}",
"schema": schema,
"table_name": table,
"text": table_representation,
}
def snapshot(self):
pass
def close(self):
pass
pl = Pipeline()
pl.make_document("group_key", "text")
flow = Dataflow()
flow.input(
"schema_data", SQLAlchemyInput(["postgresql://user:password@localhost/mydatabase"])
)
flow.make_document(
lambda table_data: Document(
key="key", text="text", metadata=table_data
)
)
flow.map(lambda doc: hf_document_embed(doc, tokenizer, model, length=512))
flow.output("output", QdrantOutput(collection_name="test_collection", vector_size=512))
| examples/sqlalchemy.py | bytewax-rt-embed-7069fc6 | [
{
"filename": "src/embed/stores/qdrant.py",
"retrieved_chunk": " ),\n schema=self.schema,\n )\n def build(self, worker_index, worker_count):\n return _QdrantVectorSink(self.client, self.collection_name)",
"score": 45.38248262654997
},
{
"filename": "src/embed/stores/qdrant.py",
"retrieved_chunk": " self.vector_size = vector_size\n self.schema = schema\n self.client = QdrantClient(host, port=6333)\n try:\n self.client.get_collection(collection_name=\"test_collection\")\n except UnexpectedResponse:\n self.client.recreate_collection(\n collection_name=\"test_collection\",\n vectors_config=VectorParams(\n size=self.vector_size, distance=Distance.COSINE",
"score": 37.652191251462455
},
{
"filename": "src/embed/stores/qdrant.py",
"retrieved_chunk": "class QdrantOutput(DynamicOutput):\n \"\"\"Qdrant.\n Workers are the unit of parallelism.\n Can support at-least-once processing. Messages from the resume\n epoch will be duplicated right after resume.\n \"\"\"\n def __init__(\n self, collection_name, vector_size, schema=\"\", host=\"localhost\", port=6333\n ):\n self.collection_name = collection_name",
"score": 25.387007602108113
},
{
"filename": "src/embed/sources/file.py",
"retrieved_chunk": " \"Could not import datasets python package. \"\n \"Please install it with `pip install datasets`.\"\n )\n self.dataset = load_dataset(dataset_name, split=f\"{split_part}\", streaming=True)\n def next(self):\n return next(iter(self.dataset))\n def snapshot(self):\n return None\nclass HuggingfaceDatasetStreamingInput(PartitionedInput):\n \"\"\"Loads a huggingface dataset as a streaming input",
"score": 17.793995607802533
},
{
"filename": "src/embed/sources/url.py",
"retrieved_chunk": " return None\n self.poll_time = time()\n webpages = []\n for url in self.urls:\n page = WebPage(\n url=url, max_retries=self.max_retries, wait_time=self.wait_time\n )\n page.get_page()\n webpages.append(page)\n return webpages",
"score": 15.920990178314767
}
] | python | get_columns(table, schema=schema) |
import torch
import torchvision.transforms as T
from embed import Pipeline
from transformers import AutoFeatureExtractor
MODEL_NAME = "nateraw/vit-base-beans"
EXTRACTOR = AutoFeatureExtractor.from_pretrained(MODEL_NAME)
# Data transformation chain.
TRANSFORM_CHAIN = T.Compose(
[
# We first resize the input image to 256x256 and then we take center crop.
T.Resize(int((256 / 224) * EXTRACTOR.size["height"])),
T.CenterCrop(EXTRACTOR.size["height"]),
T.ToTensor(),
T.Normalize(mean=EXTRACTOR.image_mean, std=EXTRACTOR.image_std),
]
)
# Here, we map embedding extraction utility on our subset of candidate images.
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
pl = Pipeline(MODEL_NAME)
pl. | huggingface_input("beans", "train") |
pl.batch(length=10)
pl.embed_image(DEVICE, TRANSFORM_CHAIN)
pl.sqlite_vector_output()
| examples/image_embed.py | bytewax-rt-embed-7069fc6 | [
{
"filename": "examples/video_transcribe.py",
"retrieved_chunk": "from pydub import AudioSegment\nimport torch\nlogging.basicConfig(level=logging.INFO)\nDEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\nmodel = whisper.load_model(\"base\")\nprint(DEVICE)\nclass YouTubeInput(PartitionedInput):\n def __init__(self, urls: list, audio_only: bool = True):\n self.urls = urls\n self.audio_only = audio_only",
"score": 32.13998429122145
},
{
"filename": "examples/csv_input.py",
"retrieved_chunk": "from embed import Pipeline\npl = Pipeline(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\npl.csv_input(\"data/books.csv\")\npl.make_document(group_key=\"header1\", text=\"header2\")\npl.embed_document()\n# pl.pg_vector_output(\"test_collection\", vector_size=512)\npl.stdout()\npl.run()",
"score": 17.065389817247592
},
{
"filename": "examples/hn_embed.py",
"retrieved_chunk": "from embed import Pipeline\npl = Pipeline(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\npl.hacker_news(poll_frequency=None)\npl.parse_html()\npl.embed_document()\npl.qdrant_output(collection=\"test_collection\", vector_size=384)\npl.run(workers=8)",
"score": 17.036634483408132
},
{
"filename": "examples/sqlalchemy.py",
"retrieved_chunk": " def close(self):\n pass\npl = Pipeline()\npl.make_document(\"group_key\", \"text\")\nflow = Dataflow()\nflow.input(\n \"schema_data\", SQLAlchemyInput([\"postgresql://user:password@localhost/mydatabase\"])\n)\nflow.make_document(\n lambda table_data: Document(",
"score": 13.005066903078433
},
{
"filename": "examples/video_transcribe.py",
"retrieved_chunk": " # chunk = next(self.audio_stream)\n # self.bytes_remaining -= len(chunk)\n # byte_io = io.BytesIO(chunk)\n # audio_segment = AudioSegment.from_file(byte_io, format=self.format)\n # samples = np.array(audio_segment.get_array_of_samples()).T.astype(np.float32)\n def snapshot(self):\n pass\n def close(self):\n os.remove(self.audio_file)\nflow = Dataflow()",
"score": 11.595577346153693
}
] | python | huggingface_input("beans", "train") |
import torch
import torchvision.transforms as T
from embed import Pipeline
from transformers import AutoFeatureExtractor
MODEL_NAME = "nateraw/vit-base-beans"
EXTRACTOR = AutoFeatureExtractor.from_pretrained(MODEL_NAME)
# Data transformation chain.
TRANSFORM_CHAIN = T.Compose(
[
# We first resize the input image to 256x256 and then we take center crop.
T.Resize(int((256 / 224) * EXTRACTOR.size["height"])),
T.CenterCrop(EXTRACTOR.size["height"]),
T.ToTensor(),
T.Normalize(mean=EXTRACTOR.image_mean, std=EXTRACTOR.image_std),
]
)
# Here, we map embedding extraction utility on our subset of candidate images.
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
pl = Pipeline(MODEL_NAME)
pl.huggingface_input("beans", "train")
pl.batch(length=10)
pl. | embed_image(DEVICE, TRANSFORM_CHAIN) |
pl.sqlite_vector_output()
| examples/image_embed.py | bytewax-rt-embed-7069fc6 | [
{
"filename": "examples/video_transcribe.py",
"retrieved_chunk": "from pydub import AudioSegment\nimport torch\nlogging.basicConfig(level=logging.INFO)\nDEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\nmodel = whisper.load_model(\"base\")\nprint(DEVICE)\nclass YouTubeInput(PartitionedInput):\n def __init__(self, urls: list, audio_only: bool = True):\n self.urls = urls\n self.audio_only = audio_only",
"score": 37.73924277796745
},
{
"filename": "examples/csv_input.py",
"retrieved_chunk": "from embed import Pipeline\npl = Pipeline(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\npl.csv_input(\"data/books.csv\")\npl.make_document(group_key=\"header1\", text=\"header2\")\npl.embed_document()\n# pl.pg_vector_output(\"test_collection\", vector_size=512)\npl.stdout()\npl.run()",
"score": 30.73734706427539
},
{
"filename": "examples/hn_embed.py",
"retrieved_chunk": "from embed import Pipeline\npl = Pipeline(model_name=\"sentence-transformers/all-MiniLM-L6-v2\")\npl.hacker_news(poll_frequency=None)\npl.parse_html()\npl.embed_document()\npl.qdrant_output(collection=\"test_collection\", vector_size=384)\npl.run(workers=8)",
"score": 30.54903047695805
},
{
"filename": "examples/sqlalchemy.py",
"retrieved_chunk": " def close(self):\n pass\npl = Pipeline()\npl.make_document(\"group_key\", \"text\")\nflow = Dataflow()\nflow.input(\n \"schema_data\", SQLAlchemyInput([\"postgresql://user:password@localhost/mydatabase\"])\n)\nflow.make_document(\n lambda table_data: Document(",
"score": 23.32621902491081
},
{
"filename": "src/embed/embedding/huggingface.py",
"retrieved_chunk": "def get_image_inputs(batch, transformation_chain, device):\n \"\"\"\n Get image model inputs\n \"\"\"\n images = [image_data[\"image\"] for image_data in batch]\n image_batch_transformed = torch.stack(\n [transformation_chain(image) for image in images]\n )\n return {\"pixel_values\": image_batch_transformed.to(device)}\ndef hf_document_embed(document: Document, tokenizer, model, length=512):",
"score": 15.341558917342386
}
] | python | embed_image(DEVICE, TRANSFORM_CHAIN) |
from aiogram.dispatcher.flags import get_flag
from aiogram.utils.chat_action import ChatActionSender
from aiogram import BaseMiddleware
from config_reader import config
from custom_queue import CallCooldown
from collections import defaultdict
import asyncio
import logging
logger = logging.getLogger(__name__)
class ChatActionMiddleware(BaseMiddleware):
async def __call__(self, handler, event, data):
long_operation_type = get_flag(data, "long_operation")
if not long_operation_type:
return await handler(event, data)
async with ChatActionSender(action=long_operation_type, chat_id=event.chat.id):
return await handler(event, data)
class AccessMiddleware(BaseMiddleware):
async def __call__(self, handler, event, data):
uid = event.from_user.id
cid = event.chat.id
logger.info(f'message in chat {cid} ({event.chat.title or "private"}) from {uid} (@{event.from_user.username or event.from_user.first_name})')
if config.ignore_mode == 'whitelist' or config.ignore_mode == 'both':
if cid not in config.whitelist:
return
if config.ignore_mode == 'blacklist' or config.ignore_mode == 'both':
if uid in config. | blacklist or cid in config.blacklist: |
return
if get_flag(data, "admins_only"):
if uid not in config.adminlist:
return
return await handler(event, data)
class CooldownMiddleware(BaseMiddleware):
async def __call__(self, handler, event, data):
cooldown_seconds = get_flag(data, "cooldown")
if cooldown_seconds:
function_name = data['handler'].callback.__name__
if CallCooldown.check_call(event.from_user.id, function_name, cooldown_seconds):
return await handler(event, data)
else:
return
else:
return await handler(event, data)
class MediaGroupMiddleware(BaseMiddleware):
albums = defaultdict(lambda: [])
def __init__(self, delay = 1):
self.delay = delay
async def __call__(self, handler, event, data):
if not event.media_group_id:
return await handler(event, data)
try:
self.albums[event.media_group_id].append(event)
await asyncio.sleep(self.delay)
data["album"] = self.albums.pop(event.media_group_id)
except Exception as e:
logger.error(e)
return await handler(event, data) | middleware.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "config_reader.py",
"retrieved_chunk": "from pydantic import BaseSettings, SecretStr, validator\nfrom typing import List, Dict\nfrom typing_extensions import Literal\nfrom utils import update_env\nclass Settings(BaseSettings):\n bot_token: SecretStr\n adminlist: List[int]\n whitelist: List[int]\n blacklist: List[int]\n ignore_mode: Literal[\"blacklist\", \"whitelist\", \"both\"]",
"score": 71.76206797310874
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " 'author': message.from_user.first_name.replace(' ', '') or 'User',\n 'chat_id': get_chat_id(message),\n 'user_id': message.from_user.id,\n **additional\n }\n def __init__(self, dp, bot):\n self.queue = UserLimitedQueue(config.llm_queue_size_per_user)\n self.semaphore = asyncio.Semaphore(1)\n self.chatter = chroniclers['chat'](config.llm_character, False, config.llm_max_history_items)\n self.assistant = chroniclers[config.llm_assistant_chronicler](config.llm_character)",
"score": 56.421286855127484
},
{
"filename": "modules/llm.py",
"retrieved_chunk": "import json\ndef get_chat_id(message):\n return message.from_user.id if config.llm_history_grouping == 'user' else message.chat.id\ndef assistant_model_available(model):\n return (hasattr(model, 'assistant_mode') and model.assistant_mode) or \\\n config.llm_force_assistant_for_unsupported_models\ndef visual_mode_available(model):\n return (hasattr(model, 'visual_mode') and model.assistant_mode)\nclass LargeLanguageModel:\n async def assist(self, text, context):",
"score": 54.19996595619522
},
{
"filename": "modules/tts.py",
"retrieved_chunk": " self.queue = UserLimitedQueue(config.tts_queue_size_per_user)\n self.semaphore = asyncio.Semaphore(1)\n so_vits_svc_voices = list(v['voice'].lower().replace('-','') for v in config.tts_so_vits_svc_voices)\n all_voices = [*config.tts_voices, *so_vits_svc_voices]\n @dp.message(Command(commands=[\"tts\", *config.tts_voices, *so_vits_svc_voices]), flags={\"long_operation\": \"record_audio\"})\n async def command_tts_handler(message: Message, command: CommandObject) -> None:\n with self.queue.for_user(message.from_user.id) as available:\n if available:\n #show helper message if no voice is selected\n if command.command == \"tts\" or not command.args or str(command.args).strip() == \"\" or ('-help' in str(command.args)):",
"score": 51.352098013962724
},
{
"filename": "modules/stt.py",
"retrieved_chunk": " error, text = await self.recognize_voice_message(message)\n if text and 'llm' in config.active_modules:\n llm = dp['modules']['llm']\n llm_call_func = llm.assist if config.stt_autoreply_mode == 'assist' else llm.chat\n reply = await llm_call_func(text, llm.get_common_chat_attributes(message))\n if 'tts' in config.active_modules:\n voice = config.stt_autoreply_voice or config.tts_voices[0]\n voice = random.choice(config.tts_voices) if voice == 'random' else voice\n await bot.reply_tts(message=message, command=SimpleNamespace(command=voice, args=[reply]))\n else:",
"score": 41.68846091840869
}
] | python | blacklist or cid in config.blacklist: |
from aiogram.filters import Command, CommandObject
from aiogram.types import Message, BufferedInputFile
from providers.tts_provider import tts, remote_tts, convert_to_ogg, so_vits_svc
from custom_queue import UserLimitedQueue, semaphore_wrapper
from config_reader import config
from utils import download_audio
import asyncio
import tempfile
class TextToSpeechModule:
def __init__(self, dp, bot):
self.queue = UserLimitedQueue(config.tts_queue_size_per_user)
self.semaphore = asyncio.Semaphore(1)
so_vits_svc_voices = list(v['voice'].lower().replace('-','') for v in config.tts_so_vits_svc_voices)
all_voices = [*config.tts_voices, *so_vits_svc_voices]
@dp.message(Command(commands=["tts", *config.tts_voices, *so_vits_svc_voices]), flags={"long_operation": "record_audio"})
async def command_tts_handler(message: Message, command: CommandObject) -> None:
with self.queue.for_user(message.from_user.id) as available:
if available:
#show helper message if no voice is selected
if command.command == "tts" or not command.args or str(command.args).strip() == "" or ('-help' in str(command.args)):
return await message.answer(f"usage: {' '.join(['/' + x for x in all_voices])} text, /revoice [recording]\nUse the commands like /command@botname \n{config. | tts_credits}") |
voice = command.command
text = str(command.args)
task_function = remote_tts if config.tts_mode != 'local' else tts
wrapped_runner = semaphore_wrapper(self.semaphore, task_function)
error, data = await wrapped_runner(voice, text)
if error:
return await message.answer(f"Error, <b>{error}</b>")
else:
audio = BufferedInputFile(convert_to_ogg(data), 'tts.ogg')
return await message.answer_voice(voice=audio)
if config.tts_enable_so_vits_svc:
@dp.message(Command(commands=["revoice", "sts"]), flags={"long_operation": "record_audio"})
async def revoice(message: Message, command: CommandObject) -> None:
voice = str(command.args).split(' ')[0] if command.args else so_vits_svc_voices[0]
voice = voice if voice in so_vits_svc_voices else None
if not voice:
return await message.answer("<b>Voice not found</b>, available speech-to-speech voices: " +
", ".join(so_vits_svc_voices))
if message.reply_to_message:
if message.reply_to_message.voice:
with tempfile.NamedTemporaryFile(suffix='.ogg', delete=False) as temp_file:
await download_audio(bot, message.reply_to_message.voice.file_id, temp_file.name)
wrapped_runner = semaphore_wrapper(self.semaphore, so_vits_svc)
error, data = await wrapped_runner(voice, None, temp_file.name)
if error:
return await message.answer(f"Error, <b>{error}</b>")
else:
audio = BufferedInputFile(convert_to_ogg(data), 'tts.ogg')
return await message.answer_voice(voice=audio)
return await message.answer("No audio found. Use this command replying to voice messages")
bot.reply_tts = command_tts_handler
| modules/tts.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "modules/stt.py",
"retrieved_chunk": " return await message.answer(reply)\n if error:\n return await message.answer(f\"Error, <b>{error}</b>\")\n @dp.message(Command(commands=[\"stt\", \"recognize\", \"transcribe\"]), flags={\"long_operation\": \"typing\"})\n async def command_stt_handler(message: Message, command: CommandObject) -> None:\n with self.queue.for_user(message.from_user.id) as available:\n if not available:\n return\n if command.command == \"stt\" and ('-h' in str(command.args) or not (message.reply_to_message and message.reply_to_message.voice)):\n return await message.answer(f\"Usage: /stt [voice_message] \\nUse the commands like /command@botname\")",
"score": 130.67069525575081
},
{
"filename": "modules/tta.py",
"retrieved_chunk": " if command.command == \"tta\" or not command.args or str(command.args).strip() == \"\" or ('-help' in str(command.args)):\n return await message.answer(f\"Usage: /sfx text /music text\\nUse the commands like /command@botname\")\n else:\n audio_type = command.command\n text = str(command.args)\n wrapped_runner = semaphore_wrapper(self.semaphore, generate_audio_async)\n error, data = await wrapped_runner(text, audio_type, config.tta_duration)\n print(error, data)\n if error:\n return await message.answer(f\"Error, <b>{error}</b>\")",
"score": 115.25204072447166
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " or (visual_mode_available(model) and parse_photo(message)) or parse_reply:\n command = SimpleNamespace(args=message.text, parse_reply=parse_reply)\n return await assist_message(message=message, command=command)\n with self.queue.for_user(message.from_user.id) as available:\n if available:\n output = await self.chat(message.text, self.get_common_chat_attributes(message))\n await message.reply(text=html.quote(output))\n @dp.message(Command(commands=['reset', 'clear']), flags={\"cooldown\": 20})\n async def clear_llm_history(message: Message, command: Command):\n self.chatter.history[get_chat_id(message)] = []",
"score": 101.59006696734535
},
{
"filename": "modules/sd.py",
"retrieved_chunk": " if config.mm_preload_models_on_start:\n asyncio.run(refresh_model_list())\n @dp.message(Command(commands=[\"tti\", \"iti\", \"ttiraw\", \"itiraw\"]), flags={\"long_operation\": \"upload_photo\"})\n async def command_sd_handler(message: Message, command: CommandObject, album=False) -> None:\n with self.queue.for_user(message.from_user.id) as available:\n if available:\n parse_error, params = self.parse_input(command.args)\n if parse_error:\n return await message.answer(f\"{html.quote(parse_error)}\")\n prompt = params['prompt']",
"score": 100.74014990921187
},
{
"filename": "modules/tta.py",
"retrieved_chunk": " self.semaphore = asyncio.Semaphore(1)\n if 'tta' in config.active_modules:\n self.available = tta_init()\n if not self.available:\n return\n @dp.message(Command(commands=[\"tta\", \"sfx\", \"music\"]), flags={\"long_operation\": \"record_audio\"})\n async def command_tta_handler(message: Message, command: CommandObject) -> None:\n with self.queue.for_user(message.from_user.id) as available:\n if not available:\n return",
"score": 100.12872759039
}
] | python | tts_credits}") |
from aiogram.filters import Command, CommandObject
from aiogram.types import Message, BufferedInputFile
from providers.tts_provider import tts, remote_tts, convert_to_ogg, so_vits_svc
from custom_queue import UserLimitedQueue, semaphore_wrapper
from config_reader import config
from utils import download_audio
import asyncio
import tempfile
class TextToSpeechModule:
def __init__(self, dp, bot):
self.queue = UserLimitedQueue(config.tts_queue_size_per_user)
self.semaphore = asyncio.Semaphore(1)
so_vits_svc_voices = list(v['voice'].lower().replace('-','') for v in config.tts_so_vits_svc_voices)
all_voices = [*config.tts_voices, *so_vits_svc_voices]
@dp.message(Command(commands=["tts", *config.tts_voices, *so_vits_svc_voices]), flags={"long_operation": "record_audio"})
async def command_tts_handler(message: Message, command: CommandObject) -> None:
with self.queue.for_user(message.from_user.id) as available:
if available:
#show helper message if no voice is selected
if command.command == "tts" or not command.args or str(command.args).strip() == "" or ('-help' in str(command.args)):
return await message.answer(f"usage: {' '.join(['/' + x for x in all_voices])} text, /revoice [recording]\nUse the commands like /command@botname \n{config.tts_credits}")
voice = command.command
text = str(command.args)
task_function = remote_tts if config. | tts_mode != 'local' else tts |
wrapped_runner = semaphore_wrapper(self.semaphore, task_function)
error, data = await wrapped_runner(voice, text)
if error:
return await message.answer(f"Error, <b>{error}</b>")
else:
audio = BufferedInputFile(convert_to_ogg(data), 'tts.ogg')
return await message.answer_voice(voice=audio)
if config.tts_enable_so_vits_svc:
@dp.message(Command(commands=["revoice", "sts"]), flags={"long_operation": "record_audio"})
async def revoice(message: Message, command: CommandObject) -> None:
voice = str(command.args).split(' ')[0] if command.args else so_vits_svc_voices[0]
voice = voice if voice in so_vits_svc_voices else None
if not voice:
return await message.answer("<b>Voice not found</b>, available speech-to-speech voices: " +
", ".join(so_vits_svc_voices))
if message.reply_to_message:
if message.reply_to_message.voice:
with tempfile.NamedTemporaryFile(suffix='.ogg', delete=False) as temp_file:
await download_audio(bot, message.reply_to_message.voice.file_id, temp_file.name)
wrapped_runner = semaphore_wrapper(self.semaphore, so_vits_svc)
error, data = await wrapped_runner(voice, None, temp_file.name)
if error:
return await message.answer(f"Error, <b>{error}</b>")
else:
audio = BufferedInputFile(convert_to_ogg(data), 'tts.ogg')
return await message.answer_voice(voice=audio)
return await message.answer("No audio found. Use this command replying to voice messages")
bot.reply_tts = command_tts_handler
| modules/tts.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "modules/tta.py",
"retrieved_chunk": " if command.command == \"tta\" or not command.args or str(command.args).strip() == \"\" or ('-help' in str(command.args)):\n return await message.answer(f\"Usage: /sfx text /music text\\nUse the commands like /command@botname\")\n else:\n audio_type = command.command\n text = str(command.args)\n wrapped_runner = semaphore_wrapper(self.semaphore, generate_audio_async)\n error, data = await wrapped_runner(text, audio_type, config.tta_duration)\n print(error, data)\n if error:\n return await message.answer(f\"Error, <b>{error}</b>\")",
"score": 135.13721208671612
},
{
"filename": "modules/stt.py",
"retrieved_chunk": " return await message.answer(reply)\n if error:\n return await message.answer(f\"Error, <b>{error}</b>\")\n @dp.message(Command(commands=[\"stt\", \"recognize\", \"transcribe\"]), flags={\"long_operation\": \"typing\"})\n async def command_stt_handler(message: Message, command: CommandObject) -> None:\n with self.queue.for_user(message.from_user.id) as available:\n if not available:\n return\n if command.command == \"stt\" and ('-h' in str(command.args) or not (message.reply_to_message and message.reply_to_message.voice)):\n return await message.answer(f\"Usage: /stt [voice_message] \\nUse the commands like /command@botname\")",
"score": 132.14390425719168
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " or (visual_mode_available(model) and parse_photo(message)) or parse_reply:\n command = SimpleNamespace(args=message.text, parse_reply=parse_reply)\n return await assist_message(message=message, command=command)\n with self.queue.for_user(message.from_user.id) as available:\n if available:\n output = await self.chat(message.text, self.get_common_chat_attributes(message))\n await message.reply(text=html.quote(output))\n @dp.message(Command(commands=['reset', 'clear']), flags={\"cooldown\": 20})\n async def clear_llm_history(message: Message, command: Command):\n self.chatter.history[get_chat_id(message)] = []",
"score": 106.29514005376484
},
{
"filename": "modules/sd.py",
"retrieved_chunk": " \"long_operation\":\"choose_sticker\"\n }\n )\n async def switch_sd_model(message: Message, command: CommandObject):\n async with self.semaphore:\n if command.args in models.values():\n success = await switch_model(command.args)\n if success:\n return message.answer(f'<b>Model changed to:</b> {command.args}')\n else:",
"score": 101.79597079372698
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " @dp.message(Command(commands=['ask', 'assist']), flags={\"long_operation\": \"typing\"})\n async def assist_message(message: Message, command: Command):\n msg = str(command.args).strip()\n if not (msg and command.args):\n return\n if not assistant_model_available(model):\n return await message.reply(text='Assistant model is not available')\n img_input = {\"visual_input\": await tg_image_to_data(parse_photo(message), bot)}\\\n if visual_mode_available(model) \\\n else {}",
"score": 100.82516294475613
}
] | python | tts_mode != 'local' else tts |
from aiogram.dispatcher.flags import get_flag
from aiogram.utils.chat_action import ChatActionSender
from aiogram import BaseMiddleware
from config_reader import config
from custom_queue import CallCooldown
from collections import defaultdict
import asyncio
import logging
logger = logging.getLogger(__name__)
class ChatActionMiddleware(BaseMiddleware):
async def __call__(self, handler, event, data):
long_operation_type = get_flag(data, "long_operation")
if not long_operation_type:
return await handler(event, data)
async with ChatActionSender(action=long_operation_type, chat_id=event.chat.id):
return await handler(event, data)
class AccessMiddleware(BaseMiddleware):
async def __call__(self, handler, event, data):
uid = event.from_user.id
cid = event.chat.id
logger.info(f'message in chat {cid} ({event.chat.title or "private"}) from {uid} (@{event.from_user.username or event.from_user.first_name})')
if config. | ignore_mode == 'whitelist' or config.ignore_mode == 'both': |
if cid not in config.whitelist:
return
if config.ignore_mode == 'blacklist' or config.ignore_mode == 'both':
if uid in config.blacklist or cid in config.blacklist:
return
if get_flag(data, "admins_only"):
if uid not in config.adminlist:
return
return await handler(event, data)
class CooldownMiddleware(BaseMiddleware):
async def __call__(self, handler, event, data):
cooldown_seconds = get_flag(data, "cooldown")
if cooldown_seconds:
function_name = data['handler'].callback.__name__
if CallCooldown.check_call(event.from_user.id, function_name, cooldown_seconds):
return await handler(event, data)
else:
return
else:
return await handler(event, data)
class MediaGroupMiddleware(BaseMiddleware):
albums = defaultdict(lambda: [])
def __init__(self, delay = 1):
self.delay = delay
async def __call__(self, handler, event, data):
if not event.media_group_id:
return await handler(event, data)
try:
self.albums[event.media_group_id].append(event)
await asyncio.sleep(self.delay)
data["album"] = self.albums.pop(event.media_group_id)
except Exception as e:
logger.error(e)
return await handler(event, data) | middleware.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "modules/llm.py",
"retrieved_chunk": "import json\ndef get_chat_id(message):\n return message.from_user.id if config.llm_history_grouping == 'user' else message.chat.id\ndef assistant_model_available(model):\n return (hasattr(model, 'assistant_mode') and model.assistant_mode) or \\\n config.llm_force_assistant_for_unsupported_models\ndef visual_mode_available(model):\n return (hasattr(model, 'visual_mode') and model.assistant_mode)\nclass LargeLanguageModel:\n async def assist(self, text, context):",
"score": 53.20023451828776
},
{
"filename": "modules/admin.py",
"retrieved_chunk": " await message.reply(f'{prefix}Chat ID: {msg.chat.id}\\nUser ID: {msg.from_user.id}')",
"score": 52.971200192664014
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " 'author': message.from_user.first_name.replace(' ', '') or 'User',\n 'chat_id': get_chat_id(message),\n 'user_id': message.from_user.id,\n **additional\n }\n def __init__(self, dp, bot):\n self.queue = UserLimitedQueue(config.llm_queue_size_per_user)\n self.semaphore = asyncio.Semaphore(1)\n self.chatter = chroniclers['chat'](config.llm_character, False, config.llm_max_history_items)\n self.assistant = chroniclers[config.llm_assistant_chronicler](config.llm_character)",
"score": 52.908217499119054
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " or (visual_mode_available(model) and parse_photo(message)) or parse_reply:\n command = SimpleNamespace(args=message.text, parse_reply=parse_reply)\n return await assist_message(message=message, command=command)\n with self.queue.for_user(message.from_user.id) as available:\n if available:\n output = await self.chat(message.text, self.get_common_chat_attributes(message))\n await message.reply(text=html.quote(output))\n @dp.message(Command(commands=['reset', 'clear']), flags={\"cooldown\": 20})\n async def clear_llm_history(message: Message, command: Command):\n self.chatter.history[get_chat_id(message)] = []",
"score": 43.72581540168187
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " error, result = await wrapped_runner(text, config.llm_max_assistant_tokens, self.assistant.gen_cfg({}))\n return result\n def should_use_reply_chronicler(self, message, bot):\n reply = message.reply_to_message\n is_reply_from_bot = reply and reply.from_user.id == bot._me.id\n is_qa_format = reply and reply.text and reply.text.startswith('Q:')\n always_assist = config.llm_assistant_use_in_chat_mode and assistant_model_available(self.model)\n return is_reply_from_bot and (is_qa_format or always_assist)\n def get_common_chat_attributes(self, message, additional={}):\n return {",
"score": 36.638870467806974
}
] | python | ignore_mode == 'whitelist' or config.ignore_mode == 'both': |
import logging
from config_reader import config
from providers.llm.remote_ob import RemoteLLM
logger = logging.getLogger(__name__)
llm_host = config.llm_host
assistant_mode = True
class RemoteLLamaCPP(RemoteLLM):
async def generate(self, prompt, length=64, model_params={}, assist=True):
if config.llm_remote_launch_process_automatically:
self.run_llm_service()
data = {
'prompt': prompt,
'max_length': length,
'seed': -1,
**model_params,
}
error, response = await super(). | remote_llm_api('POST', 'completion', data) |
if not error:
logger.info(response)
return False, prompt + response.get('content')
else:
return 'Error: ' + str(error), None
init = RemoteLLamaCPP | providers/llm/remote_llama_cpp.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "providers/llm/remote_ob.py",
"retrieved_chunk": " self.model = None\n self.filename = data.get('result') if not error else 'Unknown model'\n async def generate(self, prompt, length=64, model_params={}, assist=True):\n if config.llm_remote_launch_process_automatically:\n await self.run_llm_service()\n data = {\n 'prompt': prompt,\n 'max_length': length,\n **model_params,\n }",
"score": 41.47602395001032
},
{
"filename": "providers/llm/remote_ob.py",
"retrieved_chunk": " error, response = await self.remote_llm_api('POST', 'api/v1/generate', data)\n if not error:\n response = response.get('results')[0].get('text')\n logger.info(response)\n return False, prompt + response\n else:\n return str(error), None\n async def run_llm_service(self):\n global llm_load_started, last_pid\n if llm_load_started:",
"score": 34.16845393327091
},
{
"filename": "providers/llm/remote_ob.py",
"retrieved_chunk": " except Exception:\n return 'Unknown error', None\n def __init__(self, model_paths, init_config={}):\n if config.llm_remote_launch_process_automatically and \\\n config.mm_preload_models_on_start:\n asyncio.run(self.run_llm_service())\n else:\n error, data = asyncio.run(self.remote_llm_api('GET', 'api/v1/model', {}))\n if error:\n logger.warn('Unable to get remote language model name: ' + str(error))",
"score": 22.717699144112913
},
{
"filename": "providers/llm/pytorch/gptj_provider.py",
"retrieved_chunk": " encoded_prompt = self.tokenize(prompt)\n error = None\n try:\n with ThreadPoolExecutor():\n output = await asyncio.to_thread(self.model.generate, \n input_ids=encoded_prompt,\n max_length=len(encoded_prompt[0]) + length,\n do_sample=True,\n **model_params\n )",
"score": 19.9090332285413
},
{
"filename": "servers/tts_server.py",
"retrieved_chunk": " bytes = BytesIO(open(data, mode='rb').read())\n os.remove(data)\n response = StreamingResponse(bytes, media_type='audio/wav')\n response.headers[\"Content-Disposition\"] = f\"inline; filename=record.wav\"\n return response\n return {\"data\": data}\n else:\n return {\"error\": error}\nif __name__ == \"__main__\":\n import uvicorn",
"score": 17.520944090525628
}
] | python | remote_llm_api('POST', 'completion', data) |
import logging
import automigration
from aiogram import Bot, Dispatcher
from config_reader import config
from middleware import ChatActionMiddleware, AccessMiddleware, CooldownMiddleware, MediaGroupMiddleware
from modules.sd import StableDiffusionModule
from modules.tts import TextToSpeechModule
from modules.admin import AdminModule
from modules.llm import LargeLanguageModel
from modules.tta import TextToAudioModule
from modules.stt import SpeechToTextModule
logger = logging.getLogger(__name__)
dp = Dispatcher()
dp.message.middleware(AccessMiddleware())
dp.message.middleware(ChatActionMiddleware())
dp.message.middleware(CooldownMiddleware())
dp.message.middleware(MediaGroupMiddleware())
def initialize(dp, bot):
available_modules = {
"sd": StableDiffusionModule,
"tts": TextToSpeechModule,
"tta": TextToAudioModule,
"stt": SpeechToTextModule,
"admin": AdminModule,
"llm": LargeLanguageModel
}
dp['modules'] = {}
for module in config.active_modules:
if module in available_modules:
dp['modules'][module] = available_modules[module](dp, bot)
def main():
bot = Bot(token=config. | bot_token.get_secret_value(), parse_mode="HTML") |
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s',)
initialize(dp, bot)
print('running')
dp.run_polling(bot)
if __name__ == "__main__":
main() | bot.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "modules/stt.py",
"retrieved_chunk": " error, text = await self.recognize_voice_message(message)\n if text and 'llm' in config.active_modules:\n llm = dp['modules']['llm']\n llm_call_func = llm.assist if config.stt_autoreply_mode == 'assist' else llm.chat\n reply = await llm_call_func(text, llm.get_common_chat_attributes(message))\n if 'tts' in config.active_modules:\n voice = config.stt_autoreply_voice or config.tts_voices[0]\n voice = random.choice(config.tts_voices) if voice == 'random' else voice\n await bot.reply_tts(message=message, command=SimpleNamespace(command=voice, args=[reply]))\n else:",
"score": 34.96427892828133
},
{
"filename": "providers/tts_provider.py",
"retrieved_chunk": "from utils import cprint\nfrom config_reader import config\ntry:\n import torch\n from TTS.utils.synthesizer import Synthesizer\nexcept ImportError:\n Synthesizer = None\n if 'tts' in config.active_modules and config.tts_mode == 'local':\n cprint(\"TTS module not available, please reinstall it\", color=\"red\")\nfrom pathlib import Path",
"score": 26.888587784779737
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " self.get_common_chat_attributes(message, {'img_imput': img_input})\n )\n if config.llm_assistant_use_in_chat_mode and not hasattr(command, 'command'):\n reply = html.quote(output)\n else:\n reply = f'<b>Q</b>: {msg}\\n\\n<b>A</b>: {html.quote(output)}'\n await message.reply(text=(reply), allow_sending_without_reply=True)\n @dp.message(Command(commands=['llm']), flags={\"cooldown\": 20})\n async def helpfunction(message: Message, command: Command):\n text = f'''[LLM module].",
"score": 26.36939256141683
},
{
"filename": "modules/stt.py",
"retrieved_chunk": "import asyncio\nclass SpeechToTextModule:\n def __init__(self, dp, bot):\n self.queue = UserLimitedQueue(config.stt_queue_size_per_user)\n self.semaphore = asyncio.Semaphore(1)\n self.bot = bot\n self.model = active_model.init()\n if config.stt_autoreply_mode:\n @dp.message((F.voice), flags={\"long_operation\": \"record_audio\"})\n async def handle_voice_messages(message: Message):",
"score": 23.653587746748943
},
{
"filename": "modules/admin.py",
"retrieved_chunk": "from aiogram.filters import Command, CommandObject\nfrom aiogram.types import Message\nfrom utils import parse_photo, log_exceptions\nimport logging\nlogger = logging.getLogger(__name__)\nclass AdminModule:\n def __init__(self, dp, bot):\n @dp.message(Command(commands=[\"sendpic\"]), flags={\"admins_only\": True})\n @log_exceptions(logger)\n async def send_pic(message: Message, command: CommandObject) -> None:",
"score": 21.056751759416308
}
] | python | bot_token.get_secret_value(), parse_mode="HTML") |
import torch
import sys
import psutil
from config_reader import config
from time import time
SHARED_MEMORY = sys.platform == "darwin"
GPU_AVAILABLE = torch.cuda.is_available()
def get_vram_info():
if torch.cuda.is_available():
device = torch.cuda.current_device()
vram_bytes = torch.cuda.get_device_properties(device).total_memory
try:
vram_bytes, total = torch.cuda.mem_get_info()
except Exception:
pass
vram_gb = vram_bytes / 1e9
return vram_gb
else:
return 0.0
def get_system_ram_info():
virtual_memory = psutil.virtual_memory()
memory_gb = virtual_memory.available / (1024**3)
return memory_gb
ram_available = get_system_ram_info()
class MModel:
def __init__(self, name, load, unload):
self.name = name
self.model = load()
self.load = load
self.unload = unload
def __setattr__(self, name, value):
self.__dict__[name] = value
class MemoryManager:
def __init__(self, get_memory, cached_model_count):
self.get_memory = get_memory
self.starting_memory = get_memory()
self.cache = {}
self.cached_model_count = cached_model_count
self.mm_management_policy = config.mm_management_policy
def wrap(self, model_name, load_function=None, unload_function=None, memory='auto'):
mem = self.get_memory()
# get keys and values of items with model != None as lists
[*alive_keys], [*alive_values] = zip(*((i.name, i) for i in self.cache.values() if i.model is not None)) \
if len(self.cache.keys()) > 0 else ([],[])
if config.mm_autounload_after_seconds > 0:
seconds = config.mm_autounload_after_seconds
for key in alive_keys:
if key != model_name and self.cache[key].last_used + seconds < time():
self.unload(key, 'timeout')
alive_keys.remove(key)
alive_values.remove(self.cache[key])
if model_name not in self.cache:
self.cache[model_name] = MModel(model_name, load_function, unload_function)
self.cache[model_name].last_loaded = time()
elif not self.cache[model_name].model:
self.cache[model_name].model = load_function()
self.cache[model_name].last_loaded = time()
mem_diff = mem - self.get_memory()
mem_diff = mem_diff * int(mem_diff > 0)
item = self.cache[model_name]
item.memory = (mem_diff if memory == 'auto' else memory(item.model) or mem_diff) / 1e9
item.last_used = time()
item.use_count = (item.use_count + 1) if hasattr(item, 'use_count') else 1
if self.mm_management_policy == 'COUNT' or self.mm_management_policy == 'BOTH':
cache_count = len(alive_keys)
if cache_count > 0 and cache_count > self.cached_model_count:
unloaded_key = self.unload_by_policy(model_name, alive_values)
if self.mm_management_policy == 'BOTH':
alive_keys.remove(unloaded_key)
alive_values.remove(self.cache[unloaded_key])
if self.mm_management_policy == 'MEMORY' or self.mm_management_policy == 'BOTH' \
and len(alive_values) > 0:
items_memory = list(item.memory for item in alive_values)
total_memory_used = sum(items_memory)
memory_available = self.get_memory()
if memory_available < max(items_memory) * 1.3 \
or memory_available < self.starting_memory/3 \
or total_memory_used * 1.3 > self.starting_memory:
self.unload_by_policy(model_name, alive_values)
return self.cache[model_name].model
def unload(self, name, reason):
target = self.cache[name]
if target.unload is not None:
target.unload(target.model)
self.cache[name].model = None
print('removed', name, 'from model cache by', reason)
def unload_by_policy(self, model_name, items):
if config.mm_unload_order_policy == 'LEAST_USED':
items = sorted(items, key=lambda x: x.use_count)
if config.mm_unload_order_policy == 'OLDEST_USE_TIME':
items = sorted(items, key=lambda x: x.last_used)
if config.mm_unload_order_policy == 'OLDEST_LOAD_ORDER':
items = sorted(items, key=lambda x: x.last_loaded)
if config.mm_unload_order_policy == 'MEMORY_FOOTPRINT':
items = sorted(items, key=lambda x: x.memory)[::-1]
to_unload = items[0].name
if to_unload == model_name and len(items) > 1:
to_unload = items[1].name
self.unload(to_unload, config.mm_unload_order_policy)
return to_unload
RAM = MemoryManager(get_system_ram_info, config.mm_ram_cached_model_count_limit)
VRAM = MemoryManager(get_vram_info, config. | mm_vram_cached_model_count_limit) if GPU_AVAILABLE else False |
def mload(*args, gpu=False, **kwargs):
if 'gpu' in kwargs and kwargs['gpu'] and GPU_AVAILABLE:
return VRAM.wrap(*args, **kwargs)
else:
return RAM.wrap(*args, **kwargs) | misc/memory_manager.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "config_reader.py",
"retrieved_chunk": " python_command: str\n mm_preload_models_on_start: bool\n mm_ram_cached_model_count_limit: int\n mm_vram_cached_model_count_limit: int\n mm_management_policy: Literal[\"COUNT\", \"MEMORY\", \"BOTH\", \"NONE\"]\n mm_unload_order_policy: Literal[\"LEAST_USED\", \"OLDEST_USE_TIME\", \"OLDEST_LOAD_ORDER\", \"MEMORY_FOOTPRINT\"]\n mm_autounload_after_seconds: int\n @validator('sd_max_resolution', 'sd_default_width', 'sd_default_height')\n def resolution_in_correct_ranges(cls, v):\n if v % 64 != 0 or v < 256 or v > 2048:",
"score": 30.050974184333178
},
{
"filename": "modules/sd.py",
"retrieved_chunk": " return params\n def parse_lora(self, prompt):\n if 'lora' in prompt:\n return prompt\n seamless_loras = config.sd_lora_custom_activations or {}\n for key in seamless_loras:\n if type(seamless_loras[key]) is list:\n prompt = prompt.replace(key, random.choice(seamless_loras[key]))\\\n .replace('LORA_RANGES', str(random.choice([0.9, 0.95, 1.0, 1.1, 1.2])))\n else:",
"score": 23.316765543199082
},
{
"filename": "modules/tts.py",
"retrieved_chunk": " return await message.answer(f\"usage: {' '.join(['/' + x for x in all_voices])} text, /revoice [recording]\\nUse the commands like /command@botname \\n{config.tts_credits}\")\n voice = command.command\n text = str(command.args)\n task_function = remote_tts if config.tts_mode != 'local' else tts\n wrapped_runner = semaphore_wrapper(self.semaphore, task_function)\n error, data = await wrapped_runner(voice, text)\n if error:\n return await message.answer(f\"Error, <b>{error}</b>\")\n else:\n audio = BufferedInputFile(convert_to_ogg(data), 'tts.ogg')",
"score": 21.194756098027216
},
{
"filename": "automigration.py",
"retrieved_chunk": " 'llm_python_model_type': 'cerebras_gpt'\n}\ndef check_deprecated_keys_in_dotenv():\n for key in system_env:\n if key in DEPRECATED_KEYS:\n cprint(f'Warning! The key \"{key}\" has been deprecated! See CHANGELOG.md.', color='red')\n value = system_env[key]\n if len(value) < 1:\n continue\n if (value[0] != '[' and value[0] != '{'):",
"score": 21.061094155534658
},
{
"filename": "providers/sd_provider.py",
"retrieved_chunk": " \"height\": config.sd_default_height,\n \"restore_faces\": False,\n \"tiling\": False,\n \"batch_size\": 1,\n \"n_iter\": config.sd_default_n_iter,\n \"negative_prompt\": \"\",\n \"eta\": 71337\n}\n# hash: name\nmodels = defaultdict(lambda: 'Unknown model')",
"score": 20.99701873240499
}
] | python | mm_vram_cached_model_count_limit) if GPU_AVAILABLE else False |
import torch
import sys
import psutil
from config_reader import config
from time import time
SHARED_MEMORY = sys.platform == "darwin"
GPU_AVAILABLE = torch.cuda.is_available()
def get_vram_info():
if torch.cuda.is_available():
device = torch.cuda.current_device()
vram_bytes = torch.cuda.get_device_properties(device).total_memory
try:
vram_bytes, total = torch.cuda.mem_get_info()
except Exception:
pass
vram_gb = vram_bytes / 1e9
return vram_gb
else:
return 0.0
def get_system_ram_info():
virtual_memory = psutil.virtual_memory()
memory_gb = virtual_memory.available / (1024**3)
return memory_gb
ram_available = get_system_ram_info()
class MModel:
def __init__(self, name, load, unload):
self.name = name
self.model = load()
self.load = load
self.unload = unload
def __setattr__(self, name, value):
self.__dict__[name] = value
class MemoryManager:
def __init__(self, get_memory, cached_model_count):
self.get_memory = get_memory
self.starting_memory = get_memory()
self.cache = {}
self.cached_model_count = cached_model_count
self.mm_management_policy = config.mm_management_policy
def wrap(self, model_name, load_function=None, unload_function=None, memory='auto'):
mem = self.get_memory()
# get keys and values of items with model != None as lists
[*alive_keys], [*alive_values] = zip(*((i.name, i) for i in self.cache.values() if i.model is not None)) \
if len(self.cache.keys()) > 0 else ([],[])
if config. | mm_autounload_after_seconds > 0: |
seconds = config.mm_autounload_after_seconds
for key in alive_keys:
if key != model_name and self.cache[key].last_used + seconds < time():
self.unload(key, 'timeout')
alive_keys.remove(key)
alive_values.remove(self.cache[key])
if model_name not in self.cache:
self.cache[model_name] = MModel(model_name, load_function, unload_function)
self.cache[model_name].last_loaded = time()
elif not self.cache[model_name].model:
self.cache[model_name].model = load_function()
self.cache[model_name].last_loaded = time()
mem_diff = mem - self.get_memory()
mem_diff = mem_diff * int(mem_diff > 0)
item = self.cache[model_name]
item.memory = (mem_diff if memory == 'auto' else memory(item.model) or mem_diff) / 1e9
item.last_used = time()
item.use_count = (item.use_count + 1) if hasattr(item, 'use_count') else 1
if self.mm_management_policy == 'COUNT' or self.mm_management_policy == 'BOTH':
cache_count = len(alive_keys)
if cache_count > 0 and cache_count > self.cached_model_count:
unloaded_key = self.unload_by_policy(model_name, alive_values)
if self.mm_management_policy == 'BOTH':
alive_keys.remove(unloaded_key)
alive_values.remove(self.cache[unloaded_key])
if self.mm_management_policy == 'MEMORY' or self.mm_management_policy == 'BOTH' \
and len(alive_values) > 0:
items_memory = list(item.memory for item in alive_values)
total_memory_used = sum(items_memory)
memory_available = self.get_memory()
if memory_available < max(items_memory) * 1.3 \
or memory_available < self.starting_memory/3 \
or total_memory_used * 1.3 > self.starting_memory:
self.unload_by_policy(model_name, alive_values)
return self.cache[model_name].model
def unload(self, name, reason):
target = self.cache[name]
if target.unload is not None:
target.unload(target.model)
self.cache[name].model = None
print('removed', name, 'from model cache by', reason)
def unload_by_policy(self, model_name, items):
if config.mm_unload_order_policy == 'LEAST_USED':
items = sorted(items, key=lambda x: x.use_count)
if config.mm_unload_order_policy == 'OLDEST_USE_TIME':
items = sorted(items, key=lambda x: x.last_used)
if config.mm_unload_order_policy == 'OLDEST_LOAD_ORDER':
items = sorted(items, key=lambda x: x.last_loaded)
if config.mm_unload_order_policy == 'MEMORY_FOOTPRINT':
items = sorted(items, key=lambda x: x.memory)[::-1]
to_unload = items[0].name
if to_unload == model_name and len(items) > 1:
to_unload = items[1].name
self.unload(to_unload, config.mm_unload_order_policy)
return to_unload
RAM = MemoryManager(get_system_ram_info, config.mm_ram_cached_model_count_limit)
VRAM = MemoryManager(get_vram_info, config.mm_vram_cached_model_count_limit) if GPU_AVAILABLE else False
def mload(*args, gpu=False, **kwargs):
if 'gpu' in kwargs and kwargs['gpu'] and GPU_AVAILABLE:
return VRAM.wrap(*args, **kwargs)
else:
return RAM.wrap(*args, **kwargs) | misc/memory_manager.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "providers/sd_provider.py",
"retrieved_chunk": "async def sd_get_images(payload, endpoint):\n if len(models.values()) == 0:\n await refresh_model_list()\n async with httpx.AsyncClient() as client:\n try:\n response = await client.post(url=f'{sd_url}/{endpoint}', json=payload, timeout=None)\n if response.status_code == 200:\n response_data = response.json()\n images = response_data.get(\"images\")\n bstr_images = [b642img(i) for i in images]",
"score": 48.032508650827154
},
{
"filename": "modules/sd.py",
"retrieved_chunk": " images = [InputMediaPhoto(\n type='photo', \n media=BufferedInputFile(i, filename='image.png'), \n caption= None if idx != 0 else (f'<pre>{html.quote(prompt[0:768])}</pre>\\n' + \n f'Seed: {details.get(\"seed\")}\\n' +\n f'Sampler: {details.get(\"sampler_name\")}\\n' +\n f'Cfg scale: {details.get(\"cfg_scale\")}\\n' + \n f'Steps: {details.get(\"steps\")}\\n' +\n f'Model: {details.get(\"model\")}')\n ) for idx, i in enumerate(data)]",
"score": 36.2259959626459
},
{
"filename": "modules/stt.py",
"retrieved_chunk": " else:\n error, text = await self.recognize_voice_message(message)\n if error:\n return await message.answer(f\"Error, <b>{error}</b>\")\n else:\n return await message.answer(f\"<i>{text}</i>\")\n async def recognize_voice_message(self, message):\n with tempfile.NamedTemporaryFile(suffix='.ogg', delete=False) as temp_file:\n voice = message.reply_to_message.voice if not message.voice else message.voice\n await download_audio(self.bot, voice.file_id, temp_file.name)",
"score": 34.115512456341676
},
{
"filename": "config_reader.py",
"retrieved_chunk": " raise ValueError('incorrect value')\n return v\n @validator('tts_so_vits_svc_voices')\n def base_voices_exist(cls, v, values):\n if not values['tts_enable_so_vits_svc']:\n return v\n for item in v:\n provider = item.get('provider', values['tts_so_vits_svc_base_tts_provider'])\n if provider == 'built_in':\n if item['base_voice'] not in values['tts_voices']:",
"score": 29.449455958744366
},
{
"filename": "utils.py",
"retrieved_chunk": " def error(self, message):\n raise Exception(message)\n# join the rest of the arguments, so they can be validated\nclass JoinNargsAction(argparse.Action):\n def __call__(self, parser, namespace, values, option_string=None):\n setattr(namespace, self.dest, ' '.join(values))\ndef parse_photo(message):\n if message.photo:\n return message.photo\n if message.document and message.document.mime_type.startswith('image'):",
"score": 27.576056817309087
}
] | python | mm_autounload_after_seconds > 0: |
import torch
import sys
import psutil
from config_reader import config
from time import time
SHARED_MEMORY = sys.platform == "darwin"
GPU_AVAILABLE = torch.cuda.is_available()
def get_vram_info():
if torch.cuda.is_available():
device = torch.cuda.current_device()
vram_bytes = torch.cuda.get_device_properties(device).total_memory
try:
vram_bytes, total = torch.cuda.mem_get_info()
except Exception:
pass
vram_gb = vram_bytes / 1e9
return vram_gb
else:
return 0.0
def get_system_ram_info():
virtual_memory = psutil.virtual_memory()
memory_gb = virtual_memory.available / (1024**3)
return memory_gb
ram_available = get_system_ram_info()
class MModel:
def __init__(self, name, load, unload):
self.name = name
self.model = load()
self.load = load
self.unload = unload
def __setattr__(self, name, value):
self.__dict__[name] = value
class MemoryManager:
def __init__(self, get_memory, cached_model_count):
self.get_memory = get_memory
self.starting_memory = get_memory()
self.cache = {}
self.cached_model_count = cached_model_count
self.mm_management_policy = config.mm_management_policy
def wrap(self, model_name, load_function=None, unload_function=None, memory='auto'):
mem = self.get_memory()
# get keys and values of items with model != None as lists
[*alive_keys], [*alive_values] = zip(*((i.name, i) for i in self.cache.values() if i.model is not None)) \
if len(self.cache.keys()) > 0 else ([],[])
if config.mm_autounload_after_seconds > 0:
seconds = config.mm_autounload_after_seconds
for key in alive_keys:
if key != model_name and self.cache[key].last_used + seconds < time():
self.unload(key, 'timeout')
alive_keys.remove(key)
alive_values.remove(self.cache[key])
if model_name not in self.cache:
self.cache[model_name] = MModel(model_name, load_function, unload_function)
self.cache[model_name].last_loaded = time()
elif not self.cache[model_name].model:
self.cache[model_name].model = load_function()
self.cache[model_name].last_loaded = time()
mem_diff = mem - self.get_memory()
mem_diff = mem_diff * int(mem_diff > 0)
item = self.cache[model_name]
item.memory = (mem_diff if memory == 'auto' else memory(item.model) or mem_diff) / 1e9
item.last_used = time()
item.use_count = (item.use_count + 1) if hasattr(item, 'use_count') else 1
if self.mm_management_policy == 'COUNT' or self.mm_management_policy == 'BOTH':
cache_count = len(alive_keys)
if cache_count > 0 and cache_count > self.cached_model_count:
unloaded_key = self.unload_by_policy(model_name, alive_values)
if self.mm_management_policy == 'BOTH':
alive_keys.remove(unloaded_key)
alive_values.remove(self.cache[unloaded_key])
if self.mm_management_policy == 'MEMORY' or self.mm_management_policy == 'BOTH' \
and len(alive_values) > 0:
items_memory = list(item.memory for item in alive_values)
total_memory_used = sum(items_memory)
memory_available = self.get_memory()
if memory_available < max(items_memory) * 1.3 \
or memory_available < self.starting_memory/3 \
or total_memory_used * 1.3 > self.starting_memory:
self.unload_by_policy(model_name, alive_values)
return self.cache[model_name].model
def unload(self, name, reason):
target = self.cache[name]
if target.unload is not None:
target.unload(target.model)
self.cache[name].model = None
print('removed', name, 'from model cache by', reason)
def unload_by_policy(self, model_name, items):
if config. | mm_unload_order_policy == 'LEAST_USED': |
items = sorted(items, key=lambda x: x.use_count)
if config.mm_unload_order_policy == 'OLDEST_USE_TIME':
items = sorted(items, key=lambda x: x.last_used)
if config.mm_unload_order_policy == 'OLDEST_LOAD_ORDER':
items = sorted(items, key=lambda x: x.last_loaded)
if config.mm_unload_order_policy == 'MEMORY_FOOTPRINT':
items = sorted(items, key=lambda x: x.memory)[::-1]
to_unload = items[0].name
if to_unload == model_name and len(items) > 1:
to_unload = items[1].name
self.unload(to_unload, config.mm_unload_order_policy)
return to_unload
RAM = MemoryManager(get_system_ram_info, config.mm_ram_cached_model_count_limit)
VRAM = MemoryManager(get_vram_info, config.mm_vram_cached_model_count_limit) if GPU_AVAILABLE else False
def mload(*args, gpu=False, **kwargs):
if 'gpu' in kwargs and kwargs['gpu'] and GPU_AVAILABLE:
return VRAM.wrap(*args, **kwargs)
else:
return RAM.wrap(*args, **kwargs) | misc/memory_manager.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "providers/llm/remote_ob.py",
"retrieved_chunk": " await self.remote_llm_api('POST', 'api/v1/model', {'action': 'load', 'model_name': config.llm_remote_model_name}),\n self.model = None\n self.filename = config.llm_remote_model_name\n llm_load_started=False\n last_pid = service.pid\n return service\ninit = RemoteLLM\nlast_pid = -1 ",
"score": 26.24449288858089
},
{
"filename": "providers/llm/remote_ob.py",
"retrieved_chunk": " except Exception:\n return 'Unknown error', None\n def __init__(self, model_paths, init_config={}):\n if config.llm_remote_launch_process_automatically and \\\n config.mm_preload_models_on_start:\n asyncio.run(self.run_llm_service())\n else:\n error, data = asyncio.run(self.remote_llm_api('GET', 'api/v1/model', {}))\n if error:\n logger.warn('Unable to get remote language model name: ' + str(error))",
"score": 25.825842846792934
},
{
"filename": "providers/tta_provider.py",
"retrieved_chunk": " model = mload('tta-' + name, loader, None)\n return model\ndef generate_audio(text, audio_type=\"music\", duration=5, raw_data=False):\n try:\n if audio_type == \"music\":\n model = get_model(config.tta_music_model, MusicGen, 'MusicGen')\n else:\n model = get_model(config.tta_sfx_model, AudioGen, 'AudioGen')\n model.set_generation_params(duration=duration)\n wav = model.generate([text])",
"score": 25.452727492123472
},
{
"filename": "characters/gptj_6B_default.py",
"retrieved_chunk": "from datetime import datetime\ndef get_chat_variables(context=None):\n intro = 'The year is {}.'.format(datetime.now().year)\n personality = 'I am a very advanced AI from another planet. I met a person, their name is {}.\\n'.format(\n context['author'] if context else ''\n )\n name = 'AI'\n return {\"intro\": intro, \"personality\": personality, 'name': name, 'pre_dialog': ''}\ndef get_generation_config(override={}):\n return {",
"score": 24.12224068601774
},
{
"filename": "providers/stt/wav2vec2.py",
"retrieved_chunk": " def __init__(self):\n if config.mm_preload_models_on_start:\n mload('st-wav2vec2', self.load, None)\n def load(self):\n processor = Wav2Vec2Processor.from_pretrained(config.stt_model_path_or_name)\n model = SpeechEncoderDecoderModel.from_pretrained(config.stt_model_path_or_name)\n if device != 'cpu':\n model = model.to(device)\n processor = processor\n return (model, processor)",
"score": 23.549139246509416
}
] | python | mm_unload_order_policy == 'LEAST_USED': |
from aiogram.dispatcher.flags import get_flag
from aiogram.utils.chat_action import ChatActionSender
from aiogram import BaseMiddleware
from config_reader import config
from custom_queue import CallCooldown
from collections import defaultdict
import asyncio
import logging
logger = logging.getLogger(__name__)
class ChatActionMiddleware(BaseMiddleware):
async def __call__(self, handler, event, data):
long_operation_type = get_flag(data, "long_operation")
if not long_operation_type:
return await handler(event, data)
async with ChatActionSender(action=long_operation_type, chat_id=event.chat.id):
return await handler(event, data)
class AccessMiddleware(BaseMiddleware):
async def __call__(self, handler, event, data):
uid = event.from_user.id
cid = event.chat.id
logger.info(f'message in chat {cid} ({event.chat.title or "private"}) from {uid} (@{event.from_user.username or event.from_user.first_name})')
if config.ignore_mode == 'whitelist' or config.ignore_mode == 'both':
if cid not in config.whitelist:
return
if config.ignore_mode == 'blacklist' or config.ignore_mode == 'both':
if uid in config.blacklist or cid in config.blacklist:
return
if get_flag(data, "admins_only"):
if uid not in config.adminlist:
return
return await handler(event, data)
class CooldownMiddleware(BaseMiddleware):
async def __call__(self, handler, event, data):
cooldown_seconds = get_flag(data, "cooldown")
if cooldown_seconds:
function_name = data['handler'].callback.__name__
if CallCooldown. | check_call(event.from_user.id, function_name, cooldown_seconds): |
return await handler(event, data)
else:
return
else:
return await handler(event, data)
class MediaGroupMiddleware(BaseMiddleware):
albums = defaultdict(lambda: [])
def __init__(self, delay = 1):
self.delay = delay
async def __call__(self, handler, event, data):
if not event.media_group_id:
return await handler(event, data)
try:
self.albums[event.media_group_id].append(event)
await asyncio.sleep(self.delay)
data["album"] = self.albums.pop(event.media_group_id)
except Exception as e:
logger.error(e)
return await handler(event, data) | middleware.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "custom_queue.py",
"retrieved_chunk": " calls = {}\n @classmethod\n def check_call(cls, uid, function_name, timeout=30):\n key = f'{uid}_{function_name}'\n if key in cls.calls:\n if time.time() - cls.calls[key] < timeout:\n return False\n cls.calls[key] = time.time()\n return True\ndef semaphore_wrapper(semaphore, callback):",
"score": 43.56578703133095
},
{
"filename": "servers/tts_server.py",
"retrieved_chunk": " bytes = BytesIO(open(data, mode='rb').read())\n os.remove(data)\n response = StreamingResponse(bytes, media_type='audio/wav')\n response.headers[\"Content-Disposition\"] = f\"inline; filename=record.wav\"\n return response\n return {\"data\": data}\n else:\n return {\"error\": error}\nif __name__ == \"__main__\":\n import uvicorn",
"score": 28.92925001927664
},
{
"filename": "providers/llm/remote_ob.py",
"retrieved_chunk": " self.model = None\n self.filename = data.get('result') if not error else 'Unknown model'\n async def generate(self, prompt, length=64, model_params={}, assist=True):\n if config.llm_remote_launch_process_automatically:\n await self.run_llm_service()\n data = {\n 'prompt': prompt,\n 'max_length': length,\n **model_params,\n }",
"score": 26.699077440318565
},
{
"filename": "modules/stt.py",
"retrieved_chunk": " wrapped_runner = semaphore_wrapper(self.semaphore, self.recognize)\n error, data = await wrapped_runner(temp_file.name)\n return error, data\n async def recognize(self, audio_path):\n return await self.model.recognize(audio_path)",
"score": 25.54756061043198
},
{
"filename": "providers/llm/remote_llama_cpp.py",
"retrieved_chunk": " data = {\n 'prompt': prompt,\n 'max_length': length,\n 'seed': -1,\n **model_params,\n }\n error, response = await super().remote_llm_api('POST', 'completion', data)\n if not error:\n logger.info(response)\n return False, prompt + response.get('content')",
"score": 25.420357148010385
}
] | python | check_call(event.from_user.id, function_name, cooldown_seconds): |
from aiogram.filters import Command, CommandObject
from aiogram.types import Message, BufferedInputFile
from aiogram import html, F
from providers.stt_provider import active_model
from custom_queue import UserLimitedQueue, semaphore_wrapper
from config_reader import config
from utils import download_audio
from types import SimpleNamespace
import random
import tempfile
import asyncio
class SpeechToTextModule:
def __init__(self, dp, bot):
self.queue = UserLimitedQueue(config.stt_queue_size_per_user)
self.semaphore = asyncio.Semaphore(1)
self.bot = bot
self.model = active_model.init()
if config.stt_autoreply_mode:
@dp.message((F.voice), flags={"long_operation": "record_audio"})
async def handle_voice_messages(message: Message):
error, text = await self.recognize_voice_message(message)
if text and 'llm' in config.active_modules:
llm = dp['modules']['llm']
llm_call_func = llm.assist if config.stt_autoreply_mode == 'assist' else llm.chat
reply = await llm_call_func(text, llm.get_common_chat_attributes(message))
if 'tts' in config.active_modules:
voice = config.stt_autoreply_voice or config. | tts_voices[0] |
voice = random.choice(config.tts_voices) if voice == 'random' else voice
await bot.reply_tts(message=message, command=SimpleNamespace(command=voice, args=[reply]))
else:
return await message.answer(reply)
if error:
return await message.answer(f"Error, <b>{error}</b>")
@dp.message(Command(commands=["stt", "recognize", "transcribe"]), flags={"long_operation": "typing"})
async def command_stt_handler(message: Message, command: CommandObject) -> None:
with self.queue.for_user(message.from_user.id) as available:
if not available:
return
if command.command == "stt" and ('-h' in str(command.args) or not (message.reply_to_message and message.reply_to_message.voice)):
return await message.answer(f"Usage: /stt [voice_message] \nUse the commands like /command@botname")
else:
error, text = await self.recognize_voice_message(message)
if error:
return await message.answer(f"Error, <b>{error}</b>")
else:
return await message.answer(f"<i>{text}</i>")
async def recognize_voice_message(self, message):
with tempfile.NamedTemporaryFile(suffix='.ogg', delete=False) as temp_file:
voice = message.reply_to_message.voice if not message.voice else message.voice
await download_audio(self.bot, voice.file_id, temp_file.name)
wrapped_runner = semaphore_wrapper(self.semaphore, self.recognize)
error, data = await wrapped_runner(temp_file.name)
return error, data
async def recognize(self, audio_path):
return await self.model.recognize(audio_path)
| modules/stt.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "modules/llm.py",
"retrieved_chunk": " self.get_common_chat_attributes(message, {'img_imput': img_input})\n )\n if config.llm_assistant_use_in_chat_mode and not hasattr(command, 'command'):\n reply = html.quote(output)\n else:\n reply = f'<b>Q</b>: {msg}\\n\\n<b>A</b>: {html.quote(output)}'\n await message.reply(text=(reply), allow_sending_without_reply=True)\n @dp.message(Command(commands=['llm']), flags={\"cooldown\": 20})\n async def helpfunction(message: Message, command: Command):\n text = f'''[LLM module].",
"score": 61.15660131739121
},
{
"filename": "bot.py",
"retrieved_chunk": " \"tts\": TextToSpeechModule,\n \"tta\": TextToAudioModule,\n \"stt\": SpeechToTextModule,\n \"admin\": AdminModule,\n \"llm\": LargeLanguageModel\n }\n dp['modules'] = {}\n for module in config.active_modules:\n if module in available_modules:\n dp['modules'][module] = available_modules[module](dp, bot)",
"score": 59.72836794269942
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " self.replier = chroniclers['reply'](config.llm_character)\n model = active_model.init(config.llm_paths, self.chatter.init_cfg())\n self.model = model\n self.chat_cfg_override = config.llm_generation_cfg_override\n self.assistant_cfg_override = config.llm_assistant_cfg_override\n @dp.message((F.text[0] if F.text else '') != '/', flags={\"long_operation\": \"typing\"})\n async def handle_messages(message: Message):\n parse_reply = self.should_use_reply_chronicler(message, bot)\n # if should be handled in assistant mode\n if (config.llm_assistant_use_in_chat_mode and assistant_model_available(model))\\",
"score": 55.828089742706254
},
{
"filename": "modules/tts.py",
"retrieved_chunk": " self.queue = UserLimitedQueue(config.tts_queue_size_per_user)\n self.semaphore = asyncio.Semaphore(1)\n so_vits_svc_voices = list(v['voice'].lower().replace('-','') for v in config.tts_so_vits_svc_voices)\n all_voices = [*config.tts_voices, *so_vits_svc_voices]\n @dp.message(Command(commands=[\"tts\", *config.tts_voices, *so_vits_svc_voices]), flags={\"long_operation\": \"record_audio\"})\n async def command_tts_handler(message: Message, command: CommandObject) -> None:\n with self.queue.for_user(message.from_user.id) as available:\n if available:\n #show helper message if no voice is selected\n if command.command == \"tts\" or not command.args or str(command.args).strip() == \"\" or ('-help' in str(command.args)):",
"score": 54.79071333561649
},
{
"filename": "modules/tts.py",
"retrieved_chunk": " return await message.answer_voice(voice=audio)\n if config.tts_enable_so_vits_svc:\n @dp.message(Command(commands=[\"revoice\", \"sts\"]), flags={\"long_operation\": \"record_audio\"})\n async def revoice(message: Message, command: CommandObject) -> None:\n voice = str(command.args).split(' ')[0] if command.args else so_vits_svc_voices[0]\n voice = voice if voice in so_vits_svc_voices else None\n if not voice:\n return await message.answer(\"<b>Voice not found</b>, available speech-to-speech voices: \" +\n \", \".join(so_vits_svc_voices))\n if message.reply_to_message:",
"score": 53.15543215574257
}
] | python | tts_voices[0] |
from aiogram.filters import Command, CommandObject
from aiogram.types import Message, BufferedInputFile
from aiogram import html, F
from providers.stt_provider import active_model
from custom_queue import UserLimitedQueue, semaphore_wrapper
from config_reader import config
from utils import download_audio
from types import SimpleNamespace
import random
import tempfile
import asyncio
class SpeechToTextModule:
def __init__(self, dp, bot):
self.queue = UserLimitedQueue(config.stt_queue_size_per_user)
self.semaphore = asyncio.Semaphore(1)
self.bot = bot
self.model = active_model.init()
if config.stt_autoreply_mode:
@dp.message((F.voice), flags={"long_operation": "record_audio"})
async def handle_voice_messages(message: Message):
error, text = await self.recognize_voice_message(message)
if text and 'llm' in config.active_modules:
llm = dp['modules']['llm']
llm_call_func = llm.assist if config.stt_autoreply_mode == 'assist' else llm.chat
reply = await llm_call_func(text, llm.get_common_chat_attributes(message))
if 'tts' in config.active_modules:
voice = config. | stt_autoreply_voice or config.tts_voices[0] |
voice = random.choice(config.tts_voices) if voice == 'random' else voice
await bot.reply_tts(message=message, command=SimpleNamespace(command=voice, args=[reply]))
else:
return await message.answer(reply)
if error:
return await message.answer(f"Error, <b>{error}</b>")
@dp.message(Command(commands=["stt", "recognize", "transcribe"]), flags={"long_operation": "typing"})
async def command_stt_handler(message: Message, command: CommandObject) -> None:
with self.queue.for_user(message.from_user.id) as available:
if not available:
return
if command.command == "stt" and ('-h' in str(command.args) or not (message.reply_to_message and message.reply_to_message.voice)):
return await message.answer(f"Usage: /stt [voice_message] \nUse the commands like /command@botname")
else:
error, text = await self.recognize_voice_message(message)
if error:
return await message.answer(f"Error, <b>{error}</b>")
else:
return await message.answer(f"<i>{text}</i>")
async def recognize_voice_message(self, message):
with tempfile.NamedTemporaryFile(suffix='.ogg', delete=False) as temp_file:
voice = message.reply_to_message.voice if not message.voice else message.voice
await download_audio(self.bot, voice.file_id, temp_file.name)
wrapped_runner = semaphore_wrapper(self.semaphore, self.recognize)
error, data = await wrapped_runner(temp_file.name)
return error, data
async def recognize(self, audio_path):
return await self.model.recognize(audio_path)
| modules/stt.py | remixer-dec-botality-ii-f8402d5 | [
{
"filename": "modules/llm.py",
"retrieved_chunk": " self.get_common_chat_attributes(message, {'img_imput': img_input})\n )\n if config.llm_assistant_use_in_chat_mode and not hasattr(command, 'command'):\n reply = html.quote(output)\n else:\n reply = f'<b>Q</b>: {msg}\\n\\n<b>A</b>: {html.quote(output)}'\n await message.reply(text=(reply), allow_sending_without_reply=True)\n @dp.message(Command(commands=['llm']), flags={\"cooldown\": 20})\n async def helpfunction(message: Message, command: Command):\n text = f'''[LLM module].",
"score": 61.15660131739121
},
{
"filename": "bot.py",
"retrieved_chunk": " \"tts\": TextToSpeechModule,\n \"tta\": TextToAudioModule,\n \"stt\": SpeechToTextModule,\n \"admin\": AdminModule,\n \"llm\": LargeLanguageModel\n }\n dp['modules'] = {}\n for module in config.active_modules:\n if module in available_modules:\n dp['modules'][module] = available_modules[module](dp, bot)",
"score": 59.72836794269942
},
{
"filename": "modules/llm.py",
"retrieved_chunk": " self.replier = chroniclers['reply'](config.llm_character)\n model = active_model.init(config.llm_paths, self.chatter.init_cfg())\n self.model = model\n self.chat_cfg_override = config.llm_generation_cfg_override\n self.assistant_cfg_override = config.llm_assistant_cfg_override\n @dp.message((F.text[0] if F.text else '') != '/', flags={\"long_operation\": \"typing\"})\n async def handle_messages(message: Message):\n parse_reply = self.should_use_reply_chronicler(message, bot)\n # if should be handled in assistant mode\n if (config.llm_assistant_use_in_chat_mode and assistant_model_available(model))\\",
"score": 55.828089742706254
},
{
"filename": "modules/tts.py",
"retrieved_chunk": " self.queue = UserLimitedQueue(config.tts_queue_size_per_user)\n self.semaphore = asyncio.Semaphore(1)\n so_vits_svc_voices = list(v['voice'].lower().replace('-','') for v in config.tts_so_vits_svc_voices)\n all_voices = [*config.tts_voices, *so_vits_svc_voices]\n @dp.message(Command(commands=[\"tts\", *config.tts_voices, *so_vits_svc_voices]), flags={\"long_operation\": \"record_audio\"})\n async def command_tts_handler(message: Message, command: CommandObject) -> None:\n with self.queue.for_user(message.from_user.id) as available:\n if available:\n #show helper message if no voice is selected\n if command.command == \"tts\" or not command.args or str(command.args).strip() == \"\" or ('-help' in str(command.args)):",
"score": 54.79071333561649
},
{
"filename": "modules/tts.py",
"retrieved_chunk": " return await message.answer_voice(voice=audio)\n if config.tts_enable_so_vits_svc:\n @dp.message(Command(commands=[\"revoice\", \"sts\"]), flags={\"long_operation\": \"record_audio\"})\n async def revoice(message: Message, command: CommandObject) -> None:\n voice = str(command.args).split(' ')[0] if command.args else so_vits_svc_voices[0]\n voice = voice if voice in so_vits_svc_voices else None\n if not voice:\n return await message.answer(\"<b>Voice not found</b>, available speech-to-speech voices: \" +\n \", \".join(so_vits_svc_voices))\n if message.reply_to_message:",
"score": 53.15543215574257
}
] | python | stt_autoreply_voice or config.tts_voices[0] |
import logging
from typing import Callable, Dict, Optional, Sequence, Union
import numpy as np
import pandas as pd
import torch
from sklearn.model_selection import train_test_split
from torch import LongTensor, Tensor
from torch.utils.data import DataLoader, Dataset
import data.datasets as datasets
from data.datasets.tabular_dataframe import TabularDataFrame
logger = logging.getLogger(__name__)
# Copied from https://github.com/pfnet-research/deep-table.
# Modified by somaonishi and shoyameguro.
class TabularDataset(Dataset):
def __init__(
self,
data: pd.DataFrame,
task: str = "binary",
continuous_columns: Optional[Sequence[str]] = None,
categorical_columns: Optional[Sequence[str]] = None,
target: Optional[Union[str, Sequence[str]]] = None,
transform: Optional[Callable] = None,
unlabel_data_rate: Optional[float] = None,
seed=42,
) -> None:
"""
Args:
data (pandas.DataFrame): DataFrame.
task (str): One of "binary", "multiclass", "regression".
Defaults to "binary".
continuous_cols (sequence of str, optional): Sequence of names of
continuous features (columns). Defaults to None.
categorical_cols (sequence of str, optional): Sequence of names of
categorical features (columns). Defaults to None.
target (str, optional): If None, `np.zeros` is set as target.
Defaults to None.
transform (callable): Method of converting Tensor data.
Defaults to None.
"""
super().__init__()
self.task = task
self.num = data.shape[0]
self.categorical_columns = categorical_columns if categorical_columns else []
self.continuous_columns = continuous_columns if continuous_columns else []
if unlabel_data_rate is not None:
if task == "regression":
stratify = None
else:
stratify = data[target]
data, unlabeled_data = train_test_split(
data, test_size=unlabel_data_rate, stratify=stratify, random_state=seed
)
self.num = data.shape[0]
self.unlabeled_num = unlabeled_data.shape[0]
logger.info(f"labeled data size: {self.num}")
logger.info(f"unlabeled data size: {self.unlabeled_num}")
if self.continuous_columns:
self.continuous = data[self.continuous_columns].values
if unlabel_data_rate is not None:
self.unlabeled_continuous = unlabeled_data[self.continuous_columns].values
if self.categorical_columns:
self.categorical = data[categorical_columns].values
if unlabel_data_rate is not None:
self.unlabeled_categorical = unlabeled_data[categorical_columns].values
if target:
self.target = data[target].values
if isinstance(target, str):
self.target = self.target.reshape(-1, 1)
else:
self.target = np.zeros((self.num, 1))
self.transform = transform
self.unlabel_data_rate = unlabel_data_rate
def __len__(self) -> int:
return self.num
def __getitem__(self, idx: int) -> Dict[str, Tensor]:
"""
Args:
idx (int): The index of the sample in the dataset.
Returns:
dict[str, Tensor]:
The returned dict has the keys {"target", "continuous", "categorical"}
and its values. If no continuous/categorical features, the returned value is `[]`.
"""
if self.task == "multiclass":
x = {
"target": torch.LongTensor(self.target[idx]),
"continuous": Tensor(self.continuous[idx]) if self.continuous_columns else [],
"categorical": LongTensor(self.categorical[idx]) if self.categorical_columns else [],
}
elif self.task in {"binary", "regression"}:
x = {
"target": torch.Tensor(self.target[idx]),
"continuous": Tensor(self.continuous[idx]) if self.continuous_columns else [],
"categorical": LongTensor(self.categorical[idx]) if self.categorical_columns else [],
}
else:
raise ValueError(f"task: {self.task} must be 'multiclass' or 'binary' or 'regression'")
if self.transform is not None:
x = self.transform(x)
if hasattr(self, "unlabeled_num"):
unlabel_idx = np.random.randint(0, self.unlabeled_num)
unlabel = {
"continuous": Tensor(self.unlabeled_continuous[unlabel_idx]) if self.continuous_columns else [],
"categorical": LongTensor(self.unlabeled_categorical[unlabel_idx]) if self.categorical_columns else [],
}
return x, unlabel
else:
return x
class TabularDatamodule:
def __init__(
self,
dataset: TabularDataFrame,
transform: Optional[Callable] = None,
train_sampler: Optional[torch.utils.data.Sampler] = None,
batch_size: int = 128,
num_workers: int = 3,
seed: int = 42,
val_size: float = 0.1,
) -> None:
# self.dataset = dataset
self.__num_categories = dataset.num_categories()
self.categorical_columns = dataset.categorical_columns
self.continuous_columns = dataset.continuous_columns
self.cat_cardinalities = dataset.cat_cardinalities(True)
self.target = dataset.target_columns
self.d_out = dataset.dim_out
dataframes = dataset.processed_dataframes(val_size=val_size, seed=seed)
self.train = dataframes["train"]
self.val = dataframes["val"]
self.test = dataframes["test"]
for k, v in dataframes.items():
logger.info(f"{k} dataset shape: {v.shape}")
self.task = dataset.task
self.transform = transform
self.train_sampler = train_sampler
self.batch_size = batch_size
self.num_workers = num_workers
if self.task == "regression":
self.y_std = dataset.y_std
self.seed = seed
@property
def num_categories(self) -> int:
return self.__num_categories
@property
def num_continuous_features(self) -> int:
return len(self.continuous_columns)
@property
def num_categorical_features(self) -> int:
return len(self.categorical_columns)
def dataloader(self, mode: str, batch_size: Optional[int] = None, transform=None, unlabel_data_rate=None):
assert mode in {"train", "val", "test"}
if not hasattr(self, mode):
return None
data = getattr(self, mode)
if mode == "test":
transform = None
if transform is None:
transform = self.transform
dataset = TabularDataset(
data=data,
task=self.task,
categorical_columns=self.categorical_columns,
continuous_columns=self.continuous_columns,
target=self.target,
transform=transform,
unlabel_data_rate=unlabel_data_rate,
seed=self.seed,
)
return DataLoader(
dataset,
batch_size if batch_size is not None else self.batch_size,
shuffle=True if mode == "train" else False,
num_workers=self.num_workers,
sampler=self.train_sampler if mode == "train" else None,
)
def get_datamodule(config) -> TabularDatamodule:
if type(config.data) == int:
dataset = datasets. | OpenmlDataset(data_id=config.data, config=config) |
else:
dataset = getattr(datasets, config.data)(config=config)
return TabularDatamodule(dataset, batch_size=config.batch_size, seed=config.seed, val_size=config.val_size)
| data/tabular_datamodule.py | somaonishi-MTR-33b87b3 | [
{
"filename": "data/datasets/openml.py",
"retrieved_chunk": " task, dim_out = get_task_and_dim_out(data_id, df, columns, cate_indicator, target_col)\n print(f\"task: {task}\")\n print(f\"dim_out: {dim_out}\")\n exit()\nclass OpenmlDataset(TabularDataFrame):\n def __init__(self, data_id, config, download: bool = False) -> None:\n super().__init__(config=config, download=download)\n dataset = openml.datasets.get_dataset(data_id)\n if config.show_data_detail:\n print_dataset_details(dataset, data_id)",
"score": 51.78823310897723
},
{
"filename": "main.py",
"retrieved_chunk": " elif config.train_mode == \"self_sl\":\n runner = SelfSLRunner(config)\n else:\n raise ValueError(f\"train mode {config.train_mode} is not defined.\")\n runner.run()\n time.sleep(1)\nif __name__ == \"__main__\":\n main()",
"score": 43.05451028164671
},
{
"filename": "runner/self_sl.py",
"retrieved_chunk": " datamodule=self.datamodule,\n batch_size=self.config.batch_size,\n eval_batch_size=self.config.eval_batch_size,\n model=self.model,\n optimizer=optimizer,\n criterion=criterion,\n device=self.device,\n epochs=self.config.epochs,\n patience=self.config.patience,\n eval_metric=self.config.eval.metric,",
"score": 42.1016791616134
},
{
"filename": "data/datasets/ca_housing.py",
"retrieved_chunk": " super().__init__(config=config, download=download)\n df = fetch_california_housing(as_frame=True).frame\n self.train, self.test = train_test_split(df, test_size=0.2, random_state=self.config.seed)\n def download(self) -> None:\n pass\n # def raw_dataframe(self, train: bool = True) -> pd.DataFrame:\n # if train:\n # return self.train\n # else:\n # return self.test",
"score": 41.94683786265658
},
{
"filename": "runner/supervised.py",
"retrieved_chunk": " )\n Trainer = getattr(trainer, self.config.model.trainer)\n logger.info(f\"Trainer is {self.config.model.trainer}.\")\n self.trainer: BaseSupervisedTrainer = Trainer(\n datamodule=self.datamodule,\n batch_size=self.config.batch_size,\n eval_batch_size=self.config.eval_batch_size,\n model=self.model,\n optimizer=optimizer,\n criterion=criterion,",
"score": 41.44980018082883
}
] | python | OpenmlDataset(data_id=config.data, config=config) |
from typing import Optional, Tuple
import torch
from torch import Tensor
from .core import FTTransformer
def mask_generator(x: Tensor, lam: float) -> Tensor:
"""
Args:
x (tensor): the input of shape (b, n, d)
lam (float): the scalar coefficient to keep unmasked.
Returns:
mask (tensor): the binary mask of shape (b, n, d)
"""
b, n, d = x.shape
ids_noise = torch.rand(b, d, device=x.device)
ids_shuffle = torch.argsort(ids_noise, dim=1)
len_unmask = int(lam * d)
ids_unmask = ids_shuffle[:, :len_unmask]
mask = torch.zeros(b, d, device=x.device)
mask[torch.arange(b)[:, None], ids_unmask] = 1
mask = mask.unsqueeze(1)
mask = mask.repeat(1, n, 1)
return mask
def hidden_mix(x: Tensor, target: Optional[Tensor], lam: float) -> Tuple[Tensor, Optional[Tensor]]:
"""
Args:
x (tensor): the input of shape (b, n, d)
target (tensor): the target labels of shape (b, num_classes)
lam (float): the scalar coefficient to keep unmasked.
Returns:
new_x (tensor): the output of shape (b, n, d) representing the mixed input data
label (tensor): the mixed target labels of shape (b, num_classes)
"""
mask = mask_generator(x, lam)
indices = torch.randperm(x.shape[0])
new_x = x * mask + x[indices] * (1 - mask)
if target is not None:
label = lam * target + (1 - lam) * target[indices]
return new_x, label
else:
return new_x, None
class FTTransformerWithHiddenMix(FTTransformer):
def forward(
self,
x_num: Optional[Tensor],
x_cat: Optional[Tensor],
target: Tensor = None,
lam: Tensor = None,
) -> Tensor:
"""
Args:
x_num (tensor): the input of shape (b, n) representing the numerical values
x_cat (tensor): the input of shape (b, n) representing the categorical values
target (tensor): the target labels of shape (b, num_classes)
lam (tensor): the scalar coefficient to keep unmasked.
Returns:
tensor: the output of shape (b, num_classes) representing the model's prediction
"""
x = self.feature_tokenizer(x_num, x_cat)
x = x + self.pos_embedding
if target is not None or lam is not None:
assert lam is not None
x, new_target = hidden_mix(x, target, lam)
x = self.cls_token(x)
x = self.transformer(x)
x = x[:, -1]
x = self.normalization(x)
x = self.activation(x)
return self. | head(x), new_target |
else:
x = self.cls_token(x)
x = self.transformer(x)
x = x[:, -1]
x = self.normalization(x)
x = self.activation(x)
return self.head(x)
| model/hidden_mix_alpha.py | somaonishi-MTR-33b87b3 | [
{
"filename": "model/mixup.py",
"retrieved_chunk": " if target is not None:\n assert lam is not None\n x, new_target = mixup_process(x, lam, target)\n x = self.head(x)\n return x, new_target\n else:\n return self.head(x)\n def forward_no_labelmix(\n self,\n x_num: Optional[Tensor],",
"score": 107.4719755712535
},
{
"filename": "model/mask_token.py",
"retrieved_chunk": " x = self.transformer(x)\n x = x[:, -1]\n x = self.normalization(x)\n x = self.activation(x)\n return self.head(x)",
"score": 78.30583579920446
},
{
"filename": "model/core/fttrans.py",
"retrieved_chunk": " x = self.transformer(x)\n x = x[:, -1]\n x = self.normalization(x)\n x = self.activation(x)\n return self.head(x)",
"score": 78.30583579920446
},
{
"filename": "model/mixup.py",
"retrieved_chunk": " \"\"\"\n Supervised\n \"\"\"\n x = self.feature_tokenizer(x_num, x_cat)\n x = x + self.pos_embedding\n x = self.cls_token(x)\n x = self.transformer(x)\n x = x[:, -1]\n x = self.normalization(x)\n x = self.activation(x)",
"score": 76.4167075280015
},
{
"filename": "model/mixup.py",
"retrieved_chunk": " x = x[:, -1]\n x = self.normalization(x)\n x = self.activation(x)\n x = mixup_process(x, alpha)\n return self.head(x)",
"score": 73.72293184224901
}
] | python | head(x), new_target |
import sys
import builtins
import importlib
import inspect
from contextlib import contextmanager
from tempfile import TemporaryDirectory
from threading import RLock
import installed
from installed.cli.parsing_comments.get_options_from_comments import get_options_from_comments
from installed.cli.parsing_arguments.get_python_file import get_python_file
def start():
python_file = get_python_file()
with installed() as context:
lock = RLock()
old_import = builtins.__import__
locations = {}
@contextmanager
def set_import():
builtins.__import__ = old_import
yield
builtins.__import__ = import_wrapper
def get_current_context(where):
if where is None:
return context
else:
with lock:
location_context = locations.get(where)
if location_context is not None:
return location_context[1]
manager = installed(where=where)
local_context = manager. | __enter__() |
locations[where] = (manager, local_context)
return local_context
def import_wrapper(name, *args, **kwargs):
splitted_name = name.split('.')
base_name = splitted_name[0]
base_sequence = '.'.join(splitted_name[:-1])
last_name = splitted_name[-1]
current_frame = inspect.currentframe()
options = get_options_from_comments(current_frame.f_back)
package_name = options.pop('package', base_name)
if 'version' in options:
package_name = f'{package_name}=={options.pop("version")}'
current_context = get_current_context(options.pop('where', None))
with lock:
with set_import():
try:
result = __import__(name, *args, **kwargs)
except (ModuleNotFoundError, ImportError) as e:
current_context.install(package_name)
result = current_context.import_here(base_name)
sys.modules[base_name] = result
if 'fromlist' in kwargs and kwargs['fromlist']:
if len(splitted_name) > 1:
for index, subname in enumerate(splitted_name):
if index:
try:
result = getattr(result, subname)
except AttributeError:
raise ImportError(f"cannot import name '{last_name}' from '{base_sequence}'")
return result
builtins.__import__ = import_wrapper
spec = importlib.util.spec_from_file_location('kek', python_file)
module = importlib.util.module_from_spec(spec)
sys.modules['__main__'] = module
spec.loader.exec_module(module)
if __name__ == "__main__":
start()
| installed/cli/main.py | pomponchik-instld-1df14ba | [
{
"filename": "installed/module/context_manager.py",
"retrieved_chunk": " with lock:\n sys.path.insert(0, sys_path)\n yield sys_path\n with lock:\n del sys.path[sys.path.index(sys_path)]\n@contextmanager\ndef pip_context(packages_names, options, logger, runner, catch_output, where):\n if where is not None:\n @contextmanager\n def create_temp_directory():",
"score": 23.247742804904064
},
{
"filename": "tests/smokes/test_smoke.py",
"retrieved_chunk": " with installed(index_url='https://test.pypi.org/simple/', r='tests/requirements_test.txt') as context:\n module = context.import_here('super_test')\n assert module.version == '0.0.1'\ndef test_set_where_and_check_path():\n with TemporaryDirectory() as where:\n with installed(where=where):\n assert sys.path[0].startswith(where)\n assert not sys.path[0].startswith(where)\ndef test_install_after():\n with installed() as context:",
"score": 17.770390805164737
},
{
"filename": "installed/module/context.py",
"retrieved_chunk": " self.logger = logger\n self.catch_output = catch_output\n self.options = options\n self.installer = installer\n def __str__(self):\n return f'<Context with path \"{self.where}\">'\n def __repr__(self):\n return f'{type(self).__name__}(\"{self.where}\")'\n def import_here(self, module_name, *args, **kwargs):\n with lock:",
"score": 16.459189671825737
},
{
"filename": "installed/module/context.py",
"retrieved_chunk": " with self.new_path(module_name):\n self.logger.info(f'importing \"{module_name}\" from \"{self.where}\", sys.path now is: {sys.path}')\n module = importlib.import_module(module_name, *args, **kwargs)\n importlib.reload(module)\n return module\n @contextmanager\n def new_path(self, module_name):\n old_path = sys.path\n sys.path = [self.where] + copy.copy(self.original_path)\n if module_name in sys.modules:",
"score": 16.281962551155
},
{
"filename": "installed/module/context_manager.py",
"retrieved_chunk": " yield where\n else:\n create_temp_directory = tempfile.TemporaryDirectory\n with create_temp_directory() as directory:\n with search_path(directory, logger, runner) as where:\n try:\n if '-r' in options or '--requirement' in options:\n runner(['-m', 'pip', 'install', f'--target={where}', *options], logger, catch_output)\n else:\n for package_name in packages_names:",
"score": 15.122218152391778
}
] | python | __enter__() |
import sys
import builtins
import importlib
import inspect
from contextlib import contextmanager
from tempfile import TemporaryDirectory
from threading import RLock
import installed
from installed.cli.parsing_comments.get_options_from_comments import get_options_from_comments
from installed.cli.parsing_arguments.get_python_file import get_python_file
def start():
python_file = get_python_file()
with installed() as context:
lock = RLock()
old_import = builtins.__import__
locations = {}
@contextmanager
def set_import():
builtins.__import__ = old_import
yield
builtins.__import__ = import_wrapper
def get_current_context(where):
if where is None:
return context
else:
with lock:
location_context = locations.get(where)
if location_context is not None:
return location_context[1]
manager = installed(where=where)
local_context = manager.__enter__()
locations[where] = (manager, local_context)
return local_context
def import_wrapper(name, *args, **kwargs):
splitted_name = name.split('.')
base_name = splitted_name[0]
base_sequence = '.'.join(splitted_name[:-1])
last_name = splitted_name[-1]
current_frame = inspect.currentframe()
options = get_options_from_comments(current_frame.f_back)
package_name = options. | pop('package', base_name) |
if 'version' in options:
package_name = f'{package_name}=={options.pop("version")}'
current_context = get_current_context(options.pop('where', None))
with lock:
with set_import():
try:
result = __import__(name, *args, **kwargs)
except (ModuleNotFoundError, ImportError) as e:
current_context.install(package_name)
result = current_context.import_here(base_name)
sys.modules[base_name] = result
if 'fromlist' in kwargs and kwargs['fromlist']:
if len(splitted_name) > 1:
for index, subname in enumerate(splitted_name):
if index:
try:
result = getattr(result, subname)
except AttributeError:
raise ImportError(f"cannot import name '{last_name}' from '{base_sequence}'")
return result
builtins.__import__ = import_wrapper
spec = importlib.util.spec_from_file_location('kek', python_file)
module = importlib.util.module_from_spec(spec)
sys.modules['__main__'] = module
spec.loader.exec_module(module)
if __name__ == "__main__":
start()
| installed/cli/main.py | pomponchik-instld-1df14ba | [
{
"filename": "tests/units/cli/parsing_comments/test_get_options_from_comments.py",
"retrieved_chunk": "def test_get_wrong_options():\n with pytest.raises(InstallingPackageError):\n options = get_options_from_comments(inspect.currentframe()) # instld: lol kek cheburek, cheburek mek\n with pytest.raises(InstallingPackageError):\n options = get_options_from_comments(inspect.currentframe()) # instld: lol\n with pytest.raises(InstallingPackageError):\n options = get_options_from_comments(inspect.currentframe()) # instld: \ndef test_get_empty_options():\n options = get_options_from_comments(inspect.currentframe())\n assert isinstance(options, dict)",
"score": 19.029315816648992
},
{
"filename": "tests/units/cli/parsing_comments/test_get_options_from_comments.py",
"retrieved_chunk": "import inspect\nimport pytest\nfrom installed.errors import InstallingPackageError\nfrom installed.cli.parsing_comments.get_options_from_comments import get_options_from_comments\ndef test_get_normal_options():\n options = get_options_from_comments(inspect.currentframe()) # instld: lol kek, cheburek mek\n assert isinstance(options, dict)\n assert len(options) == 2\n assert options['lol'] == 'kek'\n assert options['cheburek'] == 'mek'",
"score": 15.430660850255075
},
{
"filename": "installed/module/context.py",
"retrieved_chunk": " old_module = sys.modules.pop(module_name)\n else:\n old_module = None\n yield\n sys.path = old_path\n def install(self, *package_names, **options):\n if not package_names:\n raise ValueError('You need to pass at least one package name.')\n options = convert_options(options)\n with self.installer(package_names, options=options):",
"score": 15.399322292791567
},
{
"filename": "installed/common_utils/convert_options.py",
"retrieved_chunk": " name = name.replace('_', '-')\n if isinstance(value, str):\n if len(name) == 1:\n add_to_buffer(f'-{name}', value)\n else:\n add_to_buffer(f'--{name}', value)\n elif isinstance(value, bool):\n if value == True:\n if len(name) == 1:\n add_to_buffer(f'-{name.upper()}')",
"score": 12.92101218628427
},
{
"filename": "installed/module/context.py",
"retrieved_chunk": " self.logger = logger\n self.catch_output = catch_output\n self.options = options\n self.installer = installer\n def __str__(self):\n return f'<Context with path \"{self.where}\">'\n def __repr__(self):\n return f'{type(self).__name__}(\"{self.where}\")'\n def import_here(self, module_name, *args, **kwargs):\n with lock:",
"score": 11.164878165091903
}
] | python | pop('package', base_name) |
from statistics import mean
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import Tensor
from torch.cuda.amp import autocast
from torch.utils.data import DataLoader
from tqdm import tqdm
from model.core.fttrans import ProjectionHead
from ..base import BaseTrainer
# Copied from https://github.com/clabrugere/pytorch-scarf/
class NTXent(nn.Module):
def __init__(self, temperature=1.0):
"""NT-Xent loss for contrastive learning using cosine distance as similarity metric as used in [SimCLR](https://arxiv.org/abs/2002.05709).
Implementation adapted from https://theaisummer.com/simclr/#simclr-loss-implementation
Args:
temperature (float, optional): scaling factor of the similarity metric. Defaults to 1.0.
"""
super().__init__()
self.temperature = temperature
def forward(self, z_i: Tensor, z_j: Tensor):
"""Compute NT-Xent loss using only anchor and positive batches of samples. Negative samples are the 2*(N-1) samples in the batch
Args:
z_i (torch.tensor): anchor batch of samples
z_j (torch.tensor): positive batch of samples
Returns:
float: loss
"""
batch_size = z_i.size(0)
# compute similarity between the sample's embedding and its corrupted view
z = torch.cat([z_i, z_j], dim=0)
similarity = F.cosine_similarity(z.unsqueeze(1), z.unsqueeze(0), dim=2)
sim_ij = torch.diag(similarity, batch_size)
sim_ji = torch.diag(similarity, -batch_size)
positives = torch.cat([sim_ij, sim_ji], dim=0)
mask = (~torch.eye(batch_size * 2, batch_size * 2, dtype=torch.bool, device=z_i.device)).float()
numerator = torch.exp(positives / self.temperature)
denominator = mask * torch.exp(similarity / self.temperature)
all_losses = -torch.log(numerator / torch.sum(denominator, dim=1))
loss = torch.sum(all_losses) / (2 * batch_size)
return loss
class BaseSSLTrainer(BaseTrainer):
def __init__(self, **kwargs) -> None:
super().__init__(**kwargs, tensorbord_dir="./self_supervised")
new_head = ProjectionHead(self. | model.head.linear.in_features) |
self.model.head = new_head.to(self.device)
self.ssl_loss = NTXent()
def train_per_epoch(self, dataloader: DataLoader, pbar_epoch: tqdm, epoch: int) -> dict:
self.model.train()
all_loss = []
if self.scheduler is not None:
self.scheduler.step()
for batch in dataloader:
pbar_epoch.update(1)
self.optimizer.zero_grad()
with autocast(enabled=self.scaler is not None):
cont, cate, _ = self.apply_device(batch)
_, loss = self.forward(cont, cate)
if self.scaler is not None:
self.scaler.scale(loss).backward()
self.scaler.step(self.optimizer)
self.scaler.update()
else:
loss.backward()
self.optimizer.step()
all_loss.append(loss.item())
scores = {"train/self-sl-loss": mean(all_loss)}
pbar_epoch.set_description(f"epoch[{epoch} / {self.epochs}]")
pbar_epoch.set_postfix(scores)
return scores
def forward_loss(self, z_i, z_j) -> float:
return self.ssl_loss(z_i, z_j)
@torch.no_grad()
def eval(self, mode: str = "val") -> dict:
self.model.eval()
all_loss = []
for batch in self.datamodule.dataloader(mode, self.eval_batch_size):
with autocast(enabled=self.scaler is not None):
cont, cate, _ = self.apply_device(batch)
_, loss = self.forward(cont, cate)
all_loss.append(loss.item())
mean_loss = mean(all_loss)
score = {f"{mode}/self-sl-loss": mean_loss}
return score
| trainer/self_supervised/base.py | somaonishi-MTR-33b87b3 | [
{
"filename": "trainer/supervised/base.py",
"retrieved_chunk": "from ..base import BaseTrainer\nlogger = logging.getLogger(__name__)\nclass BaseSupervisedTrainer(BaseTrainer):\n def __init__(self, **kwargs) -> None:\n super().__init__(**kwargs)\n def forward(\n self,\n cont: Optional[Tensor] = None,\n cate: Optional[Tensor] = None,\n target: Tensor = None,",
"score": 31.814750631877757
},
{
"filename": "trainer/supervised/fttrans.py",
"retrieved_chunk": "import logging\nfrom typing import Optional, Tuple\nfrom torch import Tensor\nfrom .base import BaseSupervisedTrainer\nlogger = logging.getLogger(__name__)\nclass FTTransTraniner(BaseSupervisedTrainer):\n def __init__(self, **kwargs) -> None:\n super().__init__(**kwargs)\n def forward(\n self,",
"score": 30.752423569157273
},
{
"filename": "trainer/supervised/fttrans_w_scarf.py",
"retrieved_chunk": " mask = torch.bernoulli(torch.ones(x.shape) * self.mask_ratio)\n mask = mask.to(torch.float).to(self.device)\n no, dim = x.shape\n x_bar = torch.zeros([no, dim]).to(self.device)\n for i in range(dim):\n idx = torch.randperm(no)\n x_bar[:, i] = x[idx, i]\n x_tilde = x * (1 - mask) + x_bar * mask\n return x_tilde\n def apply_data_augmentation(",
"score": 29.651280605783462
},
{
"filename": "trainer/supervised/fttrans_w_scarf.py",
"retrieved_chunk": " batch_size = x.shape[0]\n no, dim = all_data.shape\n x_bar = torch.zeros([batch_size, dim]).to(self.device)\n for i in range(dim):\n idx = torch.randint(0, no, (batch_size,))\n x_bar[:, i] = all_data[idx, i]\n x_tilde = x * (1 - mask) + x_bar * mask\n return x_tilde\n def __call__(self, x: Tensor, mode: str) -> Tensor:\n \"\"\"",
"score": 29.144896381168326
},
{
"filename": "trainer/supervised/base_da.py",
"retrieved_chunk": "import logging\nfrom typing import Optional, Tuple\nimport numpy as np\nfrom torch import Tensor\nfrom .base import BaseSupervisedTrainer\nlogger = logging.getLogger(__name__)\nclass BaseDATrainer(BaseSupervisedTrainer):\n def __init__(self, p: float = 0.5, **kwargs) -> None:\n super().__init__(**kwargs)\n self.p = p",
"score": 28.312621848853738
}
] | python | model.head.linear.in_features) |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import utils
from segment_tree import SumSegmentTree, MinSegmentTree
class ReplayBuffer(object):
def __init__(self, obs_shape, capacity, device):
self.capacity = capacity
self.device = device
self.obses = np.empty((capacity, *obs_shape), dtype=np.uint8)
self.next_obses = np.empty((capacity, *obs_shape), dtype=np.uint8)
self.actions = np.empty((capacity, 1), dtype=np.int64)
self.rewards = np.empty((capacity, 1), dtype=np.float32)
self.not_dones = np.empty((capacity, 1), dtype=np.float32)
self.idx = 0
self.full = False
def __len__(self):
return self.capacity if self.full else self.idx
def add(self, obs, action, reward, next_obs, done):
np.copyto(self.obses[self.idx], obs)
np.copyto(self.actions[self.idx], action)
np.copyto(self.rewards[self.idx], reward)
np.copyto(self.next_obses[self.idx], next_obs)
np.copyto(self.not_dones[self.idx], not done)
self.idx = (self.idx + 1) % self.capacity
self.full = self.full or self.idx == 0
def fetch(self, idxs, discount, n):
assert idxs.max() + n <= len(self)
obses = self.obses[idxs]
next_obses = self.next_obses[idxs + n - 1]
obses = torch.as_tensor(obses, device=self.device).float()
next_obses = torch.as_tensor(next_obses, device=self.device).float()
actions = torch.as_tensor(self.actions[idxs], device=self.device)
rewards = np.zeros((idxs.shape[0], 1), dtype=np.float32)
not_dones = np.ones((idxs.shape[0], 1), dtype=np.float32)
for i in range(n):
rewards += (discount**n) * not_dones * np.sign(
self.rewards[idxs + i])
not_dones = np.minimum(not_dones, self.not_dones[idxs + i])
rewards = torch.as_tensor(rewards, device=self.device)
not_dones = torch.as_tensor(not_dones, device=self.device)
return obses, actions, rewards, next_obses, not_dones
def sample_idxs(self, batch_size, n):
last_idx = (self.capacity if self.full else self.idx) - (n - 1)
idxs = np.random.randint(0, last_idx, size=batch_size)
return idxs
def sample_multistep(self, batch_size, discount, n):
assert n <= self.idx or self.full
idxs = self.sample_idxs(batch_size, n)
return self.fetch(idxs, discount, n)
class PrioritizedReplayBuffer(ReplayBuffer):
def __init__(self, obs_shape, capacity, alpha, device):
super().__init__(obs_shape, capacity, device)
assert alpha >= 0
self.alpha = alpha
tree_capacity = 1
while tree_capacity < capacity:
tree_capacity *= 2
self.sum_tree = SumSegmentTree(tree_capacity)
self.min_tree = MinSegmentTree(tree_capacity)
self.max_priority = 1.0
def add(self, obs, action, reward, next_obs, done):
super().add(obs, action, reward, next_obs, done)
self.sum_tree[self.idx] = self.max_priority**self.alpha
self.min_tree[self.idx] = self.max_priority**self.alpha
def sample_idxs(self, batch_size, n):
idxs = []
p_total = self.sum_tree.sum(0, len(self) - n - 1)
every_range_len = p_total / batch_size
for i in range(batch_size):
while True:
mass = np.random.rand() * every_range_len + i * every_range_len
idx = self.sum_tree. | find_prefixsum_idx(mass) |
if idx + n <= len(self):
idxs.append(idx)
break
return np.array(idxs)
def sample_multistep(self, batch_size, beta, discount, n):
assert n <= self.idx or self.full
assert beta > 0
idxs = self.sample_idxs(batch_size, n)
weights = []
p_min = self.min_tree.min() / self.sum_tree.sum()
max_weight = (p_min * len(self))**(-beta)
for idx in idxs:
p_sample = self.sum_tree[idx] / self.sum_tree.sum()
weight = (p_sample * len(self))**(-beta)
weights.append(weight / max_weight)
weights = torch.as_tensor(np.array(weights),
device=self.device).unsqueeze(dim=1)
sample = self.fetch(idxs, discount, n)
return tuple(list(sample) + [weights, idxs])
def update_priorities(self, idxs, prios):
assert idxs.shape[0] == prios.shape[0]
for idx, prio in zip(idxs, prios):
assert prio > 0
assert 0 <= idx < len(self)
self.sum_tree[idx] = prio**self.alpha
self.min_tree[idx] = prio**self.alpha
self.max_priority = max(self.max_priority, prio)
| atari/PEER-DrQ/replay_buffer.py | sweetice-PEER-CVPR23-142442f | [
{
"filename": "atari/PEER-CURL/memory.py",
"retrieved_chunk": " # Mask for non-terminal nth next states\n nonterminal = torch.tensor([transition[self.history + self.n - 1].nonterminal], dtype=torch.float32,\n device=self.device)\n return prob, idx, tree_idx, state, action, R, next_state, nonterminal\n def sample(self, batch_size):\n p_total = self.transitions.total() # Retrieve sum of all priorities (used to create a normalised probability distribution)\n segment = p_total / batch_size # Batch size number of segments, based on sum over all probabilities\n batch = [self._get_sample_from_segment(segment, i) for i in range(batch_size)] # Get batch of valid samples\n probs, idxs, tree_idxs, states, actions, returns, next_states, nonterminals = zip(*batch)\n states, next_states, = torch.stack(states), torch.stack(next_states)",
"score": 58.849746275518186
},
{
"filename": "dmc/PEER-DrQ/replay_buffer.py",
"retrieved_chunk": " np.copyto(self.not_dones_no_max[self.idx], not done_no_max)\n self.idx = (self.idx + 1) % self.capacity\n self.full = self.full or self.idx == 0\n def sample(self, batch_size):\n idxs = np.random.randint(0,\n self.capacity if self.full else self.idx,\n size=batch_size)\n obses = self.obses[idxs]\n next_obses = self.next_obses[idxs]\n obses_aug = obses.copy()",
"score": 50.49014929412278
},
{
"filename": "dmc/PEER-CURL/utils.py",
"retrieved_chunk": " next_obses, device=self.device\n ).float()\n not_dones = torch.as_tensor(self.not_dones[idxs], device=self.device)\n return obses, actions, rewards, next_obses, not_dones\n def sample_cpc(self):\n start = time.time()\n idxs = np.random.randint(\n 0, self.capacity if self.full else self.idx, size=self.batch_size\n )\n obses = self.obses[idxs]",
"score": 42.49707362858737
},
{
"filename": "bullet_mujoco/utils.py",
"retrieved_chunk": " next_obses, device=self.device\n ).float()\n not_dones = torch.as_tensor(self.not_dones[idxs], device=self.device)\n return obses, actions, rewards, next_obses, not_dones\n def sample_cpc(self):\n start = time.time()\n idxs = np.random.randint(\n 0, self.capacity if self.full else self.idx, size=self.batch_size\n )\n obses = self.obses[idxs]",
"score": 42.49707362858737
},
{
"filename": "atari/PEER-CURL/memory.py",
"retrieved_chunk": " for t in range(self.history, self.history + self.n): # e.g. 4 5 6\n if transition[t - 1].nonterminal:\n transition[t] = self.transitions.get(idx - self.history + 1 + t)\n else:\n transition[t] = blank_trans # If prev (next) frame is terminal\n return transition\n # Returns a valid sample from a segment\n def _get_sample_from_segment(self, segment, i):\n valid = False\n while not valid:",
"score": 42.24463068031193
}
] | python | find_prefixsum_idx(mass) |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import utils
from segment_tree import SumSegmentTree, MinSegmentTree
class ReplayBuffer(object):
def __init__(self, obs_shape, capacity, device):
self.capacity = capacity
self.device = device
self.obses = np.empty((capacity, *obs_shape), dtype=np.uint8)
self.next_obses = np.empty((capacity, *obs_shape), dtype=np.uint8)
self.actions = np.empty((capacity, 1), dtype=np.int64)
self.rewards = np.empty((capacity, 1), dtype=np.float32)
self.not_dones = np.empty((capacity, 1), dtype=np.float32)
self.idx = 0
self.full = False
def __len__(self):
return self.capacity if self.full else self.idx
def add(self, obs, action, reward, next_obs, done):
np.copyto(self.obses[self.idx], obs)
np.copyto(self.actions[self.idx], action)
np.copyto(self.rewards[self.idx], reward)
np.copyto(self.next_obses[self.idx], next_obs)
np.copyto(self.not_dones[self.idx], not done)
self.idx = (self.idx + 1) % self.capacity
self.full = self.full or self.idx == 0
def fetch(self, idxs, discount, n):
assert idxs.max() + n <= len(self)
obses = self.obses[idxs]
next_obses = self.next_obses[idxs + n - 1]
obses = torch.as_tensor(obses, device=self.device).float()
next_obses = torch.as_tensor(next_obses, device=self.device).float()
actions = torch.as_tensor(self.actions[idxs], device=self.device)
rewards = np.zeros((idxs.shape[0], 1), dtype=np.float32)
not_dones = np.ones((idxs.shape[0], 1), dtype=np.float32)
for i in range(n):
rewards += (discount**n) * not_dones * np.sign(
self.rewards[idxs + i])
not_dones = np.minimum(not_dones, self.not_dones[idxs + i])
rewards = torch.as_tensor(rewards, device=self.device)
not_dones = torch.as_tensor(not_dones, device=self.device)
return obses, actions, rewards, next_obses, not_dones
def sample_idxs(self, batch_size, n):
last_idx = (self.capacity if self.full else self.idx) - (n - 1)
idxs = np.random.randint(0, last_idx, size=batch_size)
return idxs
def sample_multistep(self, batch_size, discount, n):
assert n <= self.idx or self.full
idxs = self.sample_idxs(batch_size, n)
return self.fetch(idxs, discount, n)
class PrioritizedReplayBuffer(ReplayBuffer):
def __init__(self, obs_shape, capacity, alpha, device):
super().__init__(obs_shape, capacity, device)
assert alpha >= 0
self.alpha = alpha
tree_capacity = 1
while tree_capacity < capacity:
tree_capacity *= 2
self.sum_tree = SumSegmentTree(tree_capacity)
self.min_tree = MinSegmentTree(tree_capacity)
self.max_priority = 1.0
def add(self, obs, action, reward, next_obs, done):
super().add(obs, action, reward, next_obs, done)
self.sum_tree[self.idx] = self.max_priority**self.alpha
self.min_tree[self.idx] = self.max_priority**self.alpha
def sample_idxs(self, batch_size, n):
idxs = []
p_total = self.sum_tree. | sum(0, len(self) - n - 1) |
every_range_len = p_total / batch_size
for i in range(batch_size):
while True:
mass = np.random.rand() * every_range_len + i * every_range_len
idx = self.sum_tree.find_prefixsum_idx(mass)
if idx + n <= len(self):
idxs.append(idx)
break
return np.array(idxs)
def sample_multistep(self, batch_size, beta, discount, n):
assert n <= self.idx or self.full
assert beta > 0
idxs = self.sample_idxs(batch_size, n)
weights = []
p_min = self.min_tree.min() / self.sum_tree.sum()
max_weight = (p_min * len(self))**(-beta)
for idx in idxs:
p_sample = self.sum_tree[idx] / self.sum_tree.sum()
weight = (p_sample * len(self))**(-beta)
weights.append(weight / max_weight)
weights = torch.as_tensor(np.array(weights),
device=self.device).unsqueeze(dim=1)
sample = self.fetch(idxs, discount, n)
return tuple(list(sample) + [weights, idxs])
def update_priorities(self, idxs, prios):
assert idxs.shape[0] == prios.shape[0]
for idx, prio in zip(idxs, prios):
assert prio > 0
assert 0 <= idx < len(self)
self.sum_tree[idx] = prio**self.alpha
self.min_tree[idx] = prio**self.alpha
self.max_priority = max(self.max_priority, prio)
| atari/PEER-DrQ/replay_buffer.py | sweetice-PEER-CVPR23-142442f | [
{
"filename": "dmc/PEER-DrQ/replay_buffer.py",
"retrieved_chunk": " self.idx = 0\n self.full = False\n def __len__(self):\n return self.capacity if self.full else self.idx\n def add(self, obs, action, reward, next_obs, done, done_no_max):\n np.copyto(self.obses[self.idx], obs)\n np.copyto(self.actions[self.idx], action)\n np.copyto(self.rewards[self.idx], reward)\n np.copyto(self.next_obses[self.idx], next_obs)\n np.copyto(self.not_dones[self.idx], not done)",
"score": 81.56772256326991
},
{
"filename": "dmc/PEER-CURL/utils.py",
"retrieved_chunk": " self.last_save = 0\n self.full = False\n def add(self, obs, action, reward, next_obs, done):\n np.copyto(self.obses[self.idx], obs)\n np.copyto(self.actions[self.idx], action)\n np.copyto(self.rewards[self.idx], reward)\n np.copyto(self.next_obses[self.idx], next_obs)\n np.copyto(self.not_dones[self.idx], not done)\n self.idx = (self.idx + 1) % self.capacity\n self.full = self.full or self.idx == 0",
"score": 81.11027491356226
},
{
"filename": "bullet_mujoco/utils.py",
"retrieved_chunk": " self.last_save = 0\n self.full = False\n def add(self, obs, action, reward, next_obs, done):\n np.copyto(self.obses[self.idx], obs)\n np.copyto(self.actions[self.idx], action)\n np.copyto(self.rewards[self.idx], reward)\n np.copyto(self.next_obses[self.idx], next_obs)\n np.copyto(self.not_dones[self.idx], not done)\n self.idx = (self.idx + 1) % self.capacity\n self.full = self.full or self.idx == 0",
"score": 81.11027491356226
},
{
"filename": "dmc/PEER-CURL/utils.py",
"retrieved_chunk": " reward = self.rewards[idx]\n next_obs = self.next_obses[idx]\n not_done = self.not_dones[idx]\n if self.transform:\n obs = self.transform(obs)\n next_obs = self.transform(next_obs)\n return obs, action, reward, next_obs, not_done\n def __len__(self):\n return self.capacity \nclass FrameStack(gym.Wrapper):",
"score": 71.3968471416002
},
{
"filename": "bullet_mujoco/utils.py",
"retrieved_chunk": " reward = self.rewards[idx]\n next_obs = self.next_obses[idx]\n not_done = self.not_dones[idx]\n if self.transform:\n obs = self.transform(obs)\n next_obs = self.transform(next_obs)\n return obs, action, reward, next_obs, not_done\n def __len__(self):\n return self.capacity \nclass FrameStack(gym.Wrapper):",
"score": 71.3968471416002
}
] | python | sum(0, len(self) - n - 1) |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import utils
from segment_tree import SumSegmentTree, MinSegmentTree
class ReplayBuffer(object):
def __init__(self, obs_shape, capacity, device):
self.capacity = capacity
self.device = device
self.obses = np.empty((capacity, *obs_shape), dtype=np.uint8)
self.next_obses = np.empty((capacity, *obs_shape), dtype=np.uint8)
self.actions = np.empty((capacity, 1), dtype=np.int64)
self.rewards = np.empty((capacity, 1), dtype=np.float32)
self.not_dones = np.empty((capacity, 1), dtype=np.float32)
self.idx = 0
self.full = False
def __len__(self):
return self.capacity if self.full else self.idx
def add(self, obs, action, reward, next_obs, done):
np.copyto(self.obses[self.idx], obs)
np.copyto(self.actions[self.idx], action)
np.copyto(self.rewards[self.idx], reward)
np.copyto(self.next_obses[self.idx], next_obs)
np.copyto(self.not_dones[self.idx], not done)
self.idx = (self.idx + 1) % self.capacity
self.full = self.full or self.idx == 0
def fetch(self, idxs, discount, n):
assert idxs.max() + n <= len(self)
obses = self.obses[idxs]
next_obses = self.next_obses[idxs + n - 1]
obses = torch.as_tensor(obses, device=self.device).float()
next_obses = torch.as_tensor(next_obses, device=self.device).float()
actions = torch.as_tensor(self.actions[idxs], device=self.device)
rewards = np.zeros((idxs.shape[0], 1), dtype=np.float32)
not_dones = np.ones((idxs.shape[0], 1), dtype=np.float32)
for i in range(n):
rewards += (discount**n) * not_dones * np.sign(
self.rewards[idxs + i])
not_dones = np.minimum(not_dones, self.not_dones[idxs + i])
rewards = torch.as_tensor(rewards, device=self.device)
not_dones = torch.as_tensor(not_dones, device=self.device)
return obses, actions, rewards, next_obses, not_dones
def sample_idxs(self, batch_size, n):
last_idx = (self.capacity if self.full else self.idx) - (n - 1)
idxs = np.random.randint(0, last_idx, size=batch_size)
return idxs
def sample_multistep(self, batch_size, discount, n):
assert n <= self.idx or self.full
idxs = self.sample_idxs(batch_size, n)
return self.fetch(idxs, discount, n)
class PrioritizedReplayBuffer(ReplayBuffer):
def __init__(self, obs_shape, capacity, alpha, device):
super().__init__(obs_shape, capacity, device)
assert alpha >= 0
self.alpha = alpha
tree_capacity = 1
while tree_capacity < capacity:
tree_capacity *= 2
self.sum_tree = SumSegmentTree(tree_capacity)
self.min_tree = MinSegmentTree(tree_capacity)
self.max_priority = 1.0
def add(self, obs, action, reward, next_obs, done):
super().add(obs, action, reward, next_obs, done)
self.sum_tree[self.idx] = self.max_priority**self.alpha
self.min_tree[self.idx] = self.max_priority**self.alpha
def sample_idxs(self, batch_size, n):
idxs = []
p_total = self.sum_tree.sum(0, len(self) - n - 1)
every_range_len = p_total / batch_size
for i in range(batch_size):
while True:
mass = np.random.rand() * every_range_len + i * every_range_len
idx = self.sum_tree.find_prefixsum_idx(mass)
if idx + n <= len(self):
idxs.append(idx)
break
return np.array(idxs)
def sample_multistep(self, batch_size, beta, discount, n):
assert n <= self.idx or self.full
assert beta > 0
idxs = self.sample_idxs(batch_size, n)
weights = []
p_min = self.min_tree. | min() / self.sum_tree.sum() |
max_weight = (p_min * len(self))**(-beta)
for idx in idxs:
p_sample = self.sum_tree[idx] / self.sum_tree.sum()
weight = (p_sample * len(self))**(-beta)
weights.append(weight / max_weight)
weights = torch.as_tensor(np.array(weights),
device=self.device).unsqueeze(dim=1)
sample = self.fetch(idxs, discount, n)
return tuple(list(sample) + [weights, idxs])
def update_priorities(self, idxs, prios):
assert idxs.shape[0] == prios.shape[0]
for idx, prio in zip(idxs, prios):
assert prio > 0
assert 0 <= idx < len(self)
self.sum_tree[idx] = prio**self.alpha
self.min_tree[idx] = prio**self.alpha
self.max_priority = max(self.max_priority, prio)
| atari/PEER-DrQ/replay_buffer.py | sweetice-PEER-CVPR23-142442f | [
{
"filename": "dmc/PEER-DrQ/replay_buffer.py",
"retrieved_chunk": " np.copyto(self.not_dones_no_max[self.idx], not done_no_max)\n self.idx = (self.idx + 1) % self.capacity\n self.full = self.full or self.idx == 0\n def sample(self, batch_size):\n idxs = np.random.randint(0,\n self.capacity if self.full else self.idx,\n size=batch_size)\n obses = self.obses[idxs]\n next_obses = self.next_obses[idxs]\n obses_aug = obses.copy()",
"score": 57.565124117285976
},
{
"filename": "atari/PEER-DrQ/peer.py",
"retrieved_chunk": " prioritized_replay = type(replay_buffer) == PrioritizedReplayBuffer\n if prioritized_replay:\n fraction = min(step / self.prioritized_replay_beta_steps, 1.0)\n beta = self.prioritized_replay_beta0 + fraction * (\n 1.0 - self.prioritized_replay_beta0)\n obs, action, reward, next_obs, not_done, weights, idxs = replay_buffer.sample_multistep(\n self.batch_size, beta, self.discount, self.multistep_return)\n else:\n obs, action, reward, next_obs, not_done = replay_buffer.sample_multistep(\n self.batch_size, self.discount, self.multistep_return)",
"score": 57.37258528874525
},
{
"filename": "dmc/PEER-CURL/utils.py",
"retrieved_chunk": " next_obses, device=self.device\n ).float()\n not_dones = torch.as_tensor(self.not_dones[idxs], device=self.device)\n return obses, actions, rewards, next_obses, not_dones\n def sample_cpc(self):\n start = time.time()\n idxs = np.random.randint(\n 0, self.capacity if self.full else self.idx, size=self.batch_size\n )\n obses = self.obses[idxs]",
"score": 47.190924574500464
},
{
"filename": "bullet_mujoco/utils.py",
"retrieved_chunk": " next_obses, device=self.device\n ).float()\n not_dones = torch.as_tensor(self.not_dones[idxs], device=self.device)\n return obses, actions, rewards, next_obses, not_dones\n def sample_cpc(self):\n start = time.time()\n idxs = np.random.randint(\n 0, self.capacity if self.full else self.idx, size=self.batch_size\n )\n obses = self.obses[idxs]",
"score": 47.190924574500464
},
{
"filename": "dmc/PEER-CURL/utils.py",
"retrieved_chunk": " def sample_proprio(self):\n idxs = np.random.randint(\n 0, self.capacity if self.full else self.idx, size=self.batch_size\n )\n obses = self.obses[idxs]\n next_obses = self.next_obses[idxs]\n obses = torch.as_tensor(obses, device=self.device).float()\n actions = torch.as_tensor(self.actions[idxs], device=self.device)\n rewards = torch.as_tensor(self.rewards[idxs], device=self.device)\n next_obses = torch.as_tensor(",
"score": 47.105004617850454
}
] | python | min() / self.sum_tree.sum() |
import time
import warnings
from importlib.util import find_spec
from pathlib import Path
from typing import Any, Callable, Dict, List
import hydra
from omegaconf import DictConfig
from pytorch_lightning import Callback
from pytorch_lightning.loggers import Logger
from pytorch_lightning.utilities import rank_zero_only
from src.utils import pylogger, rich_utils
log = pylogger.get_pylogger(__name__)
def task_wrapper(task_func: Callable) -> Callable:
"""Optional decorator that wraps the task function in extra utilities.
Makes multirun more resistant to failure.
Utilities:
- Calling the `utils.extras()` before the task is started
- Calling the `utils.close_loggers()` after the task is finished or failed
- Logging the exception if occurs
- Logging the output dir
"""
def wrap(cfg: DictConfig):
# execute the task
try:
# apply extra utilities
extras(cfg)
metric_dict, object_dict = task_func(cfg=cfg)
# things to do if exception occurs
except Exception as ex:
# save exception to `.log` file
log.exception("")
# when using hydra plugins like Optuna, you might want to disable raising exception
# to avoid multirun failure
raise ex
# things to always do after either success or exception
finally:
# display output dir path in terminal
log.info(f"Output dir: {cfg.paths.output_dir}")
# close loggers (even if exception occurs so multirun won't fail)
close_loggers()
return metric_dict, object_dict
return wrap
def extras(cfg: DictConfig) -> None:
"""Applies optional utilities before the task is started.
Utilities:
- Ignoring python warnings
- Setting tags from command line
- Rich config printing
"""
# return if no `extras` config
if not cfg.get("extras"):
log.warning("Extras config not found! <cfg.extras=null>")
return
# disable python warnings
if cfg.extras.get("ignore_warnings"):
log.info("Disabling python warnings! <cfg.extras.ignore_warnings=True>")
warnings.filterwarnings("ignore")
# prompt user to input tags from command line if none are provided in the config
if cfg.extras.get("enforce_tags"):
log.info("Enforcing tags! <cfg.extras.enforce_tags=True>")
rich_utils.enforce_tags(cfg, save_to_file=True)
# pretty print config tree using Rich library
if cfg.extras.get("print_config"):
log.info("Printing config tree with Rich! <cfg.extras.print_config=True>")
rich_utils. | print_config_tree(cfg, resolve=True, save_to_file=True) |
def instantiate_callbacks(callbacks_cfg: DictConfig) -> List[Callback]:
"""Instantiates callbacks from config."""
callbacks: List[Callback] = []
if not callbacks_cfg:
log.warning("No callback configs found! Skipping..")
return callbacks
if not isinstance(callbacks_cfg, DictConfig):
raise TypeError("Callbacks config must be a DictConfig!")
for _, cb_conf in callbacks_cfg.items():
if isinstance(cb_conf, DictConfig) and "_target_" in cb_conf:
log.info(f"Instantiating callback <{cb_conf._target_}>")
callbacks.append(hydra.utils.instantiate(cb_conf))
return callbacks
def instantiate_loggers(logger_cfg: DictConfig) -> List[Logger]:
"""Instantiates loggers from config."""
logger: List[Logger] = []
if not logger_cfg:
log.warning("No logger configs found! Skipping...")
return logger
if not isinstance(logger_cfg, DictConfig):
raise TypeError("Logger config must be a DictConfig!")
for _, lg_conf in logger_cfg.items():
if isinstance(lg_conf, DictConfig) and "_target_" in lg_conf:
log.info(f"Instantiating logger <{lg_conf._target_}>")
logger.append(hydra.utils.instantiate(lg_conf))
return logger
@rank_zero_only
def log_hyperparameters(object_dict: dict) -> None:
"""Controls which config parts are saved by lightning loggers.
Additionally saves:
- Number of model parameters
"""
hparams = {}
cfg = object_dict["cfg"]
model = object_dict["model"]
trainer = object_dict["trainer"]
if not trainer.logger:
log.warning("Logger not found! Skipping hyperparameter logging...")
return
hparams["model"] = cfg["model"]
# save number of model parameters
hparams["model/params/total"] = sum(p.numel() for p in model.parameters())
hparams["model/params/trainable"] = sum(
p.numel() for p in model.parameters() if p.requires_grad
)
hparams["model/params/non_trainable"] = sum(
p.numel() for p in model.parameters() if not p.requires_grad
)
hparams["data"] = cfg["data"]
hparams["trainer"] = cfg["trainer"]
hparams["callbacks"] = cfg.get("callbacks")
hparams["extras"] = cfg.get("extras")
hparams["task_name"] = cfg.get("task_name")
hparams["tags"] = cfg.get("tags")
hparams["ckpt_path"] = cfg.get("ckpt_path")
hparams["seed"] = cfg.get("seed")
# send hparams to all loggers
for logger in trainer.loggers:
logger.log_hyperparams(hparams)
def get_metric_value(metric_dict: dict, metric_name: str) -> float:
"""Safely retrieves value of the metric logged in LightningModule."""
if not metric_name:
log.info("Metric name is None! Skipping metric value retrieval...")
return None
if metric_name not in metric_dict:
raise Exception(
f"Metric value not found! <metric_name={metric_name}>\n"
"Make sure metric name logged in LightningModule is correct!\n"
"Make sure `optimized_metric` name in `hparams_search` config is correct!"
)
metric_value = metric_dict[metric_name].item()
log.info(f"Retrieved metric value! <{metric_name}={metric_value}>")
return metric_value
def close_loggers() -> None:
"""Makes sure all loggers closed properly (prevents logging failure during multirun)."""
log.info("Closing loggers...")
if find_spec("wandb"): # if wandb is installed
import wandb
if wandb.run:
log.info("Closing wandb!")
wandb.finish()
@rank_zero_only
def save_file(path: str, content: str) -> None:
"""Save file in rank zero mode (only on one process in multi-GPU setup)."""
with open(path, "w+") as file:
file.write(content)
| src/utils/utils.py | janghyuk-choi-slot-attention-lightning-2993443 | [
{
"filename": "src/utils/rich_utils.py",
"retrieved_chunk": "@rank_zero_only\ndef enforce_tags(cfg: DictConfig, save_to_file: bool = False) -> None:\n \"\"\"Prompts user to input tags from command line if no tags are provided in config.\"\"\"\n if not cfg.get(\"tags\"):\n if \"id\" in HydraConfig().cfg.hydra.job:\n raise ValueError(\"Specify tags before launching a multirun!\")\n log.warning(\"No tags provided in config. Prompting user to input tags...\")\n tags = Prompt.ask(\"Enter a list of comma separated tags\", default=\"dev\")\n tags = [t.strip() for t in tags.split(\",\") if t != \"\"]\n with open_dict(cfg):",
"score": 122.44166144404925
},
{
"filename": "src/utils/rich_utils.py",
"retrieved_chunk": " \"paths\",\n \"extras\",\n ),\n resolve: bool = False,\n save_to_file: bool = False,\n) -> None:\n \"\"\"Prints content of DictConfig using Rich library and its tree structure.\n Args:\n cfg (DictConfig): Configuration composed by Hydra.\n print_order (Sequence[str], optional): Determines in what order config components are printed.",
"score": 104.37014519921546
},
{
"filename": "tests/conftest.py",
"retrieved_chunk": " cfg.data.pin_memory = False\n cfg.extras.print_config = False\n cfg.extras.enforce_tags = False\n cfg.logger = None\n return cfg\[email protected](scope=\"package\")\ndef cfg_eval_global() -> DictConfig:\n with initialize(version_base=\"1.3\", config_path=\"../configs\"):\n cfg = compose(config_name=\"eval.yaml\", return_hydra_config=True, overrides=[\"ckpt_path=.\"])\n # set defaults for all tests",
"score": 94.18543044474082
},
{
"filename": "src/utils/rich_utils.py",
"retrieved_chunk": " cfg.tags = tags\n log.info(f\"Tags: {cfg.tags}\")\n if save_to_file:\n with open(Path(cfg.paths.output_dir, \"tags.log\"), \"w\") as file:\n rich.print(cfg.tags, file=file)",
"score": 90.77169609284142
},
{
"filename": "tests/conftest.py",
"retrieved_chunk": " with open_dict(cfg):\n cfg.paths.root_dir = str(pyrootutils.find_root(indicator=\".project-root\"))\n cfg.trainer.max_epochs = 1\n cfg.trainer.limit_test_batches = 0.1\n cfg.trainer.accelerator = \"cpu\"\n cfg.trainer.devices = 1\n cfg.data.num_workers = 0\n cfg.data.pin_memory = False\n cfg.extras.print_config = False\n cfg.extras.enforce_tags = False",
"score": 89.66905444414431
}
] | python | print_config_tree(cfg, resolve=True, save_to_file=True) |
import time
import warnings
from importlib.util import find_spec
from pathlib import Path
from typing import Any, Callable, Dict, List
import hydra
from omegaconf import DictConfig
from pytorch_lightning import Callback
from pytorch_lightning.loggers import Logger
from pytorch_lightning.utilities import rank_zero_only
from src.utils import pylogger, rich_utils
log = pylogger.get_pylogger(__name__)
def task_wrapper(task_func: Callable) -> Callable:
"""Optional decorator that wraps the task function in extra utilities.
Makes multirun more resistant to failure.
Utilities:
- Calling the `utils.extras()` before the task is started
- Calling the `utils.close_loggers()` after the task is finished or failed
- Logging the exception if occurs
- Logging the output dir
"""
def wrap(cfg: DictConfig):
# execute the task
try:
# apply extra utilities
extras(cfg)
metric_dict, object_dict = task_func(cfg=cfg)
# things to do if exception occurs
except Exception as ex:
# save exception to `.log` file
log.exception("")
# when using hydra plugins like Optuna, you might want to disable raising exception
# to avoid multirun failure
raise ex
# things to always do after either success or exception
finally:
# display output dir path in terminal
log.info(f"Output dir: {cfg.paths.output_dir}")
# close loggers (even if exception occurs so multirun won't fail)
close_loggers()
return metric_dict, object_dict
return wrap
def extras(cfg: DictConfig) -> None:
"""Applies optional utilities before the task is started.
Utilities:
- Ignoring python warnings
- Setting tags from command line
- Rich config printing
"""
# return if no `extras` config
if not cfg.get("extras"):
log.warning("Extras config not found! <cfg.extras=null>")
return
# disable python warnings
if cfg.extras.get("ignore_warnings"):
log.info("Disabling python warnings! <cfg.extras.ignore_warnings=True>")
warnings.filterwarnings("ignore")
# prompt user to input tags from command line if none are provided in the config
if cfg.extras.get("enforce_tags"):
log.info("Enforcing tags! <cfg.extras.enforce_tags=True>")
rich_utils. | enforce_tags(cfg, save_to_file=True) |
# pretty print config tree using Rich library
if cfg.extras.get("print_config"):
log.info("Printing config tree with Rich! <cfg.extras.print_config=True>")
rich_utils.print_config_tree(cfg, resolve=True, save_to_file=True)
def instantiate_callbacks(callbacks_cfg: DictConfig) -> List[Callback]:
"""Instantiates callbacks from config."""
callbacks: List[Callback] = []
if not callbacks_cfg:
log.warning("No callback configs found! Skipping..")
return callbacks
if not isinstance(callbacks_cfg, DictConfig):
raise TypeError("Callbacks config must be a DictConfig!")
for _, cb_conf in callbacks_cfg.items():
if isinstance(cb_conf, DictConfig) and "_target_" in cb_conf:
log.info(f"Instantiating callback <{cb_conf._target_}>")
callbacks.append(hydra.utils.instantiate(cb_conf))
return callbacks
def instantiate_loggers(logger_cfg: DictConfig) -> List[Logger]:
"""Instantiates loggers from config."""
logger: List[Logger] = []
if not logger_cfg:
log.warning("No logger configs found! Skipping...")
return logger
if not isinstance(logger_cfg, DictConfig):
raise TypeError("Logger config must be a DictConfig!")
for _, lg_conf in logger_cfg.items():
if isinstance(lg_conf, DictConfig) and "_target_" in lg_conf:
log.info(f"Instantiating logger <{lg_conf._target_}>")
logger.append(hydra.utils.instantiate(lg_conf))
return logger
@rank_zero_only
def log_hyperparameters(object_dict: dict) -> None:
"""Controls which config parts are saved by lightning loggers.
Additionally saves:
- Number of model parameters
"""
hparams = {}
cfg = object_dict["cfg"]
model = object_dict["model"]
trainer = object_dict["trainer"]
if not trainer.logger:
log.warning("Logger not found! Skipping hyperparameter logging...")
return
hparams["model"] = cfg["model"]
# save number of model parameters
hparams["model/params/total"] = sum(p.numel() for p in model.parameters())
hparams["model/params/trainable"] = sum(
p.numel() for p in model.parameters() if p.requires_grad
)
hparams["model/params/non_trainable"] = sum(
p.numel() for p in model.parameters() if not p.requires_grad
)
hparams["data"] = cfg["data"]
hparams["trainer"] = cfg["trainer"]
hparams["callbacks"] = cfg.get("callbacks")
hparams["extras"] = cfg.get("extras")
hparams["task_name"] = cfg.get("task_name")
hparams["tags"] = cfg.get("tags")
hparams["ckpt_path"] = cfg.get("ckpt_path")
hparams["seed"] = cfg.get("seed")
# send hparams to all loggers
for logger in trainer.loggers:
logger.log_hyperparams(hparams)
def get_metric_value(metric_dict: dict, metric_name: str) -> float:
"""Safely retrieves value of the metric logged in LightningModule."""
if not metric_name:
log.info("Metric name is None! Skipping metric value retrieval...")
return None
if metric_name not in metric_dict:
raise Exception(
f"Metric value not found! <metric_name={metric_name}>\n"
"Make sure metric name logged in LightningModule is correct!\n"
"Make sure `optimized_metric` name in `hparams_search` config is correct!"
)
metric_value = metric_dict[metric_name].item()
log.info(f"Retrieved metric value! <{metric_name}={metric_value}>")
return metric_value
def close_loggers() -> None:
"""Makes sure all loggers closed properly (prevents logging failure during multirun)."""
log.info("Closing loggers...")
if find_spec("wandb"): # if wandb is installed
import wandb
if wandb.run:
log.info("Closing wandb!")
wandb.finish()
@rank_zero_only
def save_file(path: str, content: str) -> None:
"""Save file in rank zero mode (only on one process in multi-GPU setup)."""
with open(path, "w+") as file:
file.write(content)
| src/utils/utils.py | janghyuk-choi-slot-attention-lightning-2993443 | [
{
"filename": "src/utils/rich_utils.py",
"retrieved_chunk": "@rank_zero_only\ndef enforce_tags(cfg: DictConfig, save_to_file: bool = False) -> None:\n \"\"\"Prompts user to input tags from command line if no tags are provided in config.\"\"\"\n if not cfg.get(\"tags\"):\n if \"id\" in HydraConfig().cfg.hydra.job:\n raise ValueError(\"Specify tags before launching a multirun!\")\n log.warning(\"No tags provided in config. Prompting user to input tags...\")\n tags = Prompt.ask(\"Enter a list of comma separated tags\", default=\"dev\")\n tags = [t.strip() for t in tags.split(\",\") if t != \"\"]\n with open_dict(cfg):",
"score": 103.61162102074806
},
{
"filename": "tests/conftest.py",
"retrieved_chunk": " cfg.data.pin_memory = False\n cfg.extras.print_config = False\n cfg.extras.enforce_tags = False\n cfg.logger = None\n return cfg\[email protected](scope=\"package\")\ndef cfg_eval_global() -> DictConfig:\n with initialize(version_base=\"1.3\", config_path=\"../configs\"):\n cfg = compose(config_name=\"eval.yaml\", return_hydra_config=True, overrides=[\"ckpt_path=.\"])\n # set defaults for all tests",
"score": 73.95549620746296
},
{
"filename": "src/utils/rich_utils.py",
"retrieved_chunk": " cfg.tags = tags\n log.info(f\"Tags: {cfg.tags}\")\n if save_to_file:\n with open(Path(cfg.paths.output_dir, \"tags.log\"), \"w\") as file:\n rich.print(cfg.tags, file=file)",
"score": 73.19663831488532
},
{
"filename": "tests/conftest.py",
"retrieved_chunk": " with open_dict(cfg):\n cfg.paths.root_dir = str(pyrootutils.find_root(indicator=\".project-root\"))\n cfg.trainer.max_epochs = 1\n cfg.trainer.limit_test_batches = 0.1\n cfg.trainer.accelerator = \"cpu\"\n cfg.trainer.devices = 1\n cfg.data.num_workers = 0\n cfg.data.pin_memory = False\n cfg.extras.print_config = False\n cfg.extras.enforce_tags = False",
"score": 71.08928035382223
},
{
"filename": "src/train.py",
"retrieved_chunk": " log.info(f\"Instantiating datamodule <{cfg.data._target_}>\")\n datamodule: LightningDataModule = hydra.utils.instantiate(cfg.data)\n log.info(f\"Instantiating model <{cfg.model._target_}>\")\n model: LightningModule = hydra.utils.instantiate(cfg.model)\n log.info(\"Instantiating callbacks...\")\n callbacks: List[Callback] = utils.instantiate_callbacks(cfg.get(\"callbacks\"))\n log.info(\"Instantiating loggers...\")\n logger: List[Logger] = utils.instantiate_loggers(cfg.get(\"logger\"))\n log.info(f\"Instantiating trainer <{cfg.trainer._target_}>\")\n trainer: Trainer = hydra.utils.instantiate(cfg.trainer, callbacks=callbacks, logger=logger)",
"score": 56.2457984415257
}
] | python | enforce_tags(cfg, save_to_file=True) |
"""This file prepares config fixtures for other tests."""
import pyrootutils
import pytest
from hydra import compose, initialize
from hydra.core.global_hydra import GlobalHydra
from omegaconf import DictConfig, open_dict
@pytest.fixture(scope="package")
def cfg_train_global() -> DictConfig:
with initialize(version_base="1.3", config_path="../configs"):
cfg = compose(config_name="train.yaml", return_hydra_config=True, overrides=[])
# set defaults for all tests
with open_dict(cfg):
cfg.paths.root_dir = str(pyrootutils.find_root(indicator=".project-root"))
cfg.trainer.max_epochs = 1
cfg.trainer.limit_train_batches = 0.01
cfg.trainer.limit_val_batches = 0.1
cfg.trainer.limit_test_batches = 0.1
cfg.trainer.accelerator = "cpu"
cfg.trainer.devices = 1
cfg. | data.num_workers = 0 |
cfg.data.pin_memory = False
cfg.extras.print_config = False
cfg.extras.enforce_tags = False
cfg.logger = None
return cfg
@pytest.fixture(scope="package")
def cfg_eval_global() -> DictConfig:
with initialize(version_base="1.3", config_path="../configs"):
cfg = compose(config_name="eval.yaml", return_hydra_config=True, overrides=["ckpt_path=."])
# set defaults for all tests
with open_dict(cfg):
cfg.paths.root_dir = str(pyrootutils.find_root(indicator=".project-root"))
cfg.trainer.max_epochs = 1
cfg.trainer.limit_test_batches = 0.1
cfg.trainer.accelerator = "cpu"
cfg.trainer.devices = 1
cfg.data.num_workers = 0
cfg.data.pin_memory = False
cfg.extras.print_config = False
cfg.extras.enforce_tags = False
cfg.logger = None
return cfg
# this is called by each test which uses `cfg_train` arg
# each test generates its own temporary logging path
@pytest.fixture(scope="function")
def cfg_train(cfg_train_global, tmp_path) -> DictConfig:
cfg = cfg_train_global.copy()
with open_dict(cfg):
cfg.paths.output_dir = str(tmp_path)
cfg.paths.log_dir = str(tmp_path)
yield cfg
GlobalHydra.instance().clear()
# this is called by each test which uses `cfg_eval` arg
# each test generates its own temporary logging path
@pytest.fixture(scope="function")
def cfg_eval(cfg_eval_global, tmp_path) -> DictConfig:
cfg = cfg_eval_global.copy()
with open_dict(cfg):
cfg.paths.output_dir = str(tmp_path)
cfg.paths.log_dir = str(tmp_path)
yield cfg
GlobalHydra.instance().clear()
| tests/conftest.py | janghyuk-choi-slot-attention-lightning-2993443 | [
{
"filename": "src/eval.py",
"retrieved_chunk": " log.info(\"Instantiating loggers...\")\n logger: List[Logger] = utils.instantiate_loggers(cfg.get(\"logger\"))\n log.info(f\"Instantiating trainer <{cfg.trainer._target_}>\")\n trainer: Trainer = hydra.utils.instantiate(cfg.trainer, logger=logger)\n object_dict = {\n \"cfg\": cfg,\n \"datamodule\": datamodule,\n \"model\": model,\n \"logger\": logger,\n \"trainer\": trainer,",
"score": 80.9775663179131
},
{
"filename": "src/train.py",
"retrieved_chunk": " log.info(f\"Instantiating datamodule <{cfg.data._target_}>\")\n datamodule: LightningDataModule = hydra.utils.instantiate(cfg.data)\n log.info(f\"Instantiating model <{cfg.model._target_}>\")\n model: LightningModule = hydra.utils.instantiate(cfg.model)\n log.info(\"Instantiating callbacks...\")\n callbacks: List[Callback] = utils.instantiate_callbacks(cfg.get(\"callbacks\"))\n log.info(\"Instantiating loggers...\")\n logger: List[Logger] = utils.instantiate_loggers(cfg.get(\"logger\"))\n log.info(f\"Instantiating trainer <{cfg.trainer._target_}>\")\n trainer: Trainer = hydra.utils.instantiate(cfg.trainer, callbacks=callbacks, logger=logger)",
"score": 76.94696140220212
},
{
"filename": "src/utils/utils.py",
"retrieved_chunk": " hparams[\"model/params/non_trainable\"] = sum(\n p.numel() for p in model.parameters() if not p.requires_grad\n )\n hparams[\"data\"] = cfg[\"data\"]\n hparams[\"trainer\"] = cfg[\"trainer\"]\n hparams[\"callbacks\"] = cfg.get(\"callbacks\")\n hparams[\"extras\"] = cfg.get(\"extras\")\n hparams[\"task_name\"] = cfg.get(\"task_name\")\n hparams[\"tags\"] = cfg.get(\"tags\")\n hparams[\"ckpt_path\"] = cfg.get(\"ckpt_path\")",
"score": 75.68727543815412
},
{
"filename": "tests/test_sweeps.py",
"retrieved_chunk": " \"trainer.max_epochs=3\",\n \"+trainer.limit_train_batches=0.01\",\n \"+trainer.limit_val_batches=0.1\",\n \"+trainer.limit_test_batches=0.1\",\n \"logger=wandb\",\n ]\n run_sh_command(command)",
"score": 72.47818689640677
},
{
"filename": "src/train.py",
"retrieved_chunk": " object_dict = {\n \"cfg\": cfg,\n \"datamodule\": datamodule,\n \"model\": model,\n \"callbacks\": callbacks,\n \"logger\": logger,\n \"trainer\": trainer,\n }\n if logger:\n log.info(\"Logging hyperparameters!\")",
"score": 71.4007417278145
}
] | python | data.num_workers = 0 |
"""This file prepares config fixtures for other tests."""
import pyrootutils
import pytest
from hydra import compose, initialize
from hydra.core.global_hydra import GlobalHydra
from omegaconf import DictConfig, open_dict
@pytest.fixture(scope="package")
def cfg_train_global() -> DictConfig:
with initialize(version_base="1.3", config_path="../configs"):
cfg = compose(config_name="train.yaml", return_hydra_config=True, overrides=[])
# set defaults for all tests
with open_dict(cfg):
cfg.paths.root_dir = str(pyrootutils.find_root(indicator=".project-root"))
cfg.trainer.max_epochs = 1
cfg.trainer.limit_train_batches = 0.01
cfg.trainer.limit_val_batches = 0.1
cfg.trainer.limit_test_batches = 0.1
cfg.trainer.accelerator = "cpu"
cfg.trainer.devices = 1
cfg.data.num_workers = 0
cfg.data.pin_memory = False
cfg. | extras.print_config = False |
cfg.extras.enforce_tags = False
cfg.logger = None
return cfg
@pytest.fixture(scope="package")
def cfg_eval_global() -> DictConfig:
with initialize(version_base="1.3", config_path="../configs"):
cfg = compose(config_name="eval.yaml", return_hydra_config=True, overrides=["ckpt_path=."])
# set defaults for all tests
with open_dict(cfg):
cfg.paths.root_dir = str(pyrootutils.find_root(indicator=".project-root"))
cfg.trainer.max_epochs = 1
cfg.trainer.limit_test_batches = 0.1
cfg.trainer.accelerator = "cpu"
cfg.trainer.devices = 1
cfg.data.num_workers = 0
cfg.data.pin_memory = False
cfg.extras.print_config = False
cfg.extras.enforce_tags = False
cfg.logger = None
return cfg
# this is called by each test which uses `cfg_train` arg
# each test generates its own temporary logging path
@pytest.fixture(scope="function")
def cfg_train(cfg_train_global, tmp_path) -> DictConfig:
cfg = cfg_train_global.copy()
with open_dict(cfg):
cfg.paths.output_dir = str(tmp_path)
cfg.paths.log_dir = str(tmp_path)
yield cfg
GlobalHydra.instance().clear()
# this is called by each test which uses `cfg_eval` arg
# each test generates its own temporary logging path
@pytest.fixture(scope="function")
def cfg_eval(cfg_eval_global, tmp_path) -> DictConfig:
cfg = cfg_eval_global.copy()
with open_dict(cfg):
cfg.paths.output_dir = str(tmp_path)
cfg.paths.log_dir = str(tmp_path)
yield cfg
GlobalHydra.instance().clear()
| tests/conftest.py | janghyuk-choi-slot-attention-lightning-2993443 | [
{
"filename": "src/utils/utils.py",
"retrieved_chunk": " hparams[\"model/params/non_trainable\"] = sum(\n p.numel() for p in model.parameters() if not p.requires_grad\n )\n hparams[\"data\"] = cfg[\"data\"]\n hparams[\"trainer\"] = cfg[\"trainer\"]\n hparams[\"callbacks\"] = cfg.get(\"callbacks\")\n hparams[\"extras\"] = cfg.get(\"extras\")\n hparams[\"task_name\"] = cfg.get(\"task_name\")\n hparams[\"tags\"] = cfg.get(\"tags\")\n hparams[\"ckpt_path\"] = cfg.get(\"ckpt_path\")",
"score": 84.46197235983891
},
{
"filename": "src/eval.py",
"retrieved_chunk": " log.info(\"Instantiating loggers...\")\n logger: List[Logger] = utils.instantiate_loggers(cfg.get(\"logger\"))\n log.info(f\"Instantiating trainer <{cfg.trainer._target_}>\")\n trainer: Trainer = hydra.utils.instantiate(cfg.trainer, logger=logger)\n object_dict = {\n \"cfg\": cfg,\n \"datamodule\": datamodule,\n \"model\": model,\n \"logger\": logger,\n \"trainer\": trainer,",
"score": 80.9775663179131
},
{
"filename": "src/train.py",
"retrieved_chunk": " log.info(f\"Instantiating datamodule <{cfg.data._target_}>\")\n datamodule: LightningDataModule = hydra.utils.instantiate(cfg.data)\n log.info(f\"Instantiating model <{cfg.model._target_}>\")\n model: LightningModule = hydra.utils.instantiate(cfg.model)\n log.info(\"Instantiating callbacks...\")\n callbacks: List[Callback] = utils.instantiate_callbacks(cfg.get(\"callbacks\"))\n log.info(\"Instantiating loggers...\")\n logger: List[Logger] = utils.instantiate_loggers(cfg.get(\"logger\"))\n log.info(f\"Instantiating trainer <{cfg.trainer._target_}>\")\n trainer: Trainer = hydra.utils.instantiate(cfg.trainer, callbacks=callbacks, logger=logger)",
"score": 79.66278043162244
},
{
"filename": "tests/test_sweeps.py",
"retrieved_chunk": " \"trainer.max_epochs=3\",\n \"+trainer.limit_train_batches=0.01\",\n \"+trainer.limit_val_batches=0.1\",\n \"+trainer.limit_test_batches=0.1\",\n \"logger=wandb\",\n ]\n run_sh_command(command)",
"score": 72.47818689640677
},
{
"filename": "src/train.py",
"retrieved_chunk": " object_dict = {\n \"cfg\": cfg,\n \"datamodule\": datamodule,\n \"model\": model,\n \"callbacks\": callbacks,\n \"logger\": logger,\n \"trainer\": trainer,\n }\n if logger:\n log.info(\"Logging hyperparameters!\")",
"score": 71.4007417278145
}
] | python | extras.print_config = False |
from statistics import mean
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import Tensor
from torch.cuda.amp import autocast
from torch.utils.data import DataLoader
from tqdm import tqdm
from model.core.fttrans import ProjectionHead
from ..base import BaseTrainer
# Copied from https://github.com/clabrugere/pytorch-scarf/
class NTXent(nn.Module):
def __init__(self, temperature=1.0):
"""NT-Xent loss for contrastive learning using cosine distance as similarity metric as used in [SimCLR](https://arxiv.org/abs/2002.05709).
Implementation adapted from https://theaisummer.com/simclr/#simclr-loss-implementation
Args:
temperature (float, optional): scaling factor of the similarity metric. Defaults to 1.0.
"""
super().__init__()
self.temperature = temperature
def forward(self, z_i: Tensor, z_j: Tensor):
"""Compute NT-Xent loss using only anchor and positive batches of samples. Negative samples are the 2*(N-1) samples in the batch
Args:
z_i (torch.tensor): anchor batch of samples
z_j (torch.tensor): positive batch of samples
Returns:
float: loss
"""
batch_size = z_i.size(0)
# compute similarity between the sample's embedding and its corrupted view
z = torch.cat([z_i, z_j], dim=0)
similarity = F.cosine_similarity(z.unsqueeze(1), z.unsqueeze(0), dim=2)
sim_ij = torch.diag(similarity, batch_size)
sim_ji = torch.diag(similarity, -batch_size)
positives = torch.cat([sim_ij, sim_ji], dim=0)
mask = (~torch.eye(batch_size * 2, batch_size * 2, dtype=torch.bool, device=z_i.device)).float()
numerator = torch.exp(positives / self.temperature)
denominator = mask * torch.exp(similarity / self.temperature)
all_losses = -torch.log(numerator / torch.sum(denominator, dim=1))
loss = torch.sum(all_losses) / (2 * batch_size)
return loss
class BaseSSLTrainer(BaseTrainer):
def __init__(self, **kwargs) -> None:
super().__init__(**kwargs, tensorbord_dir="./self_supervised")
new_head = ProjectionHead(self.model.head.linear.in_features)
self.model.head = new_head.to(self.device)
self.ssl_loss = NTXent()
def train_per_epoch(self, dataloader: DataLoader, pbar_epoch: tqdm, epoch: int) -> dict:
self.model.train()
all_loss = []
if self.scheduler is not None:
self.scheduler.step()
for batch in dataloader:
pbar_epoch.update(1)
self.optimizer.zero_grad()
with autocast(enabled=self.scaler is not None):
cont, cate, _ = self.apply_device(batch)
_, loss = self. | forward(cont, cate) |
if self.scaler is not None:
self.scaler.scale(loss).backward()
self.scaler.step(self.optimizer)
self.scaler.update()
else:
loss.backward()
self.optimizer.step()
all_loss.append(loss.item())
scores = {"train/self-sl-loss": mean(all_loss)}
pbar_epoch.set_description(f"epoch[{epoch} / {self.epochs}]")
pbar_epoch.set_postfix(scores)
return scores
def forward_loss(self, z_i, z_j) -> float:
return self.ssl_loss(z_i, z_j)
@torch.no_grad()
def eval(self, mode: str = "val") -> dict:
self.model.eval()
all_loss = []
for batch in self.datamodule.dataloader(mode, self.eval_batch_size):
with autocast(enabled=self.scaler is not None):
cont, cate, _ = self.apply_device(batch)
_, loss = self.forward(cont, cate)
all_loss.append(loss.item())
mean_loss = mean(all_loss)
score = {f"{mode}/self-sl-loss": mean_loss}
return score
| trainer/self_supervised/base.py | somaonishi-MTR-33b87b3 | [
{
"filename": "trainer/supervised/base.py",
"retrieved_chunk": " raise NotImplementedError()\n def train_per_epoch(self, dataloader: DataLoader, pbar_epoch: tqdm, epoch: int) -> dict:\n self.model.train()\n all_loss = []\n if self.scheduler is not None:\n self.scheduler.step()\n for batch in dataloader:\n pbar_epoch.update(1)\n self.optimizer.zero_grad()\n with autocast(enabled=self.scaler is not None):",
"score": 90.05063869601129
},
{
"filename": "trainer/supervised/base.py",
"retrieved_chunk": " cont, cate, target = self.apply_device(batch)\n _, loss = self.forward(cont, cate, target)\n if self.scaler is not None:\n self.scaler.scale(loss).backward()\n self.scaler.step(self.optimizer)\n self.scaler.update()\n else:\n loss.backward()\n self.optimizer.step()\n all_loss.append(loss.item())",
"score": 77.86682305241928
},
{
"filename": "trainer/supervised/base.py",
"retrieved_chunk": " for batch in self.datamodule.dataloader(mode, self.eval_batch_size):\n with autocast(enabled=self.scaler is not None):\n cont, cate, target = self.apply_device(batch)\n out = self.model(cont, cate)\n loss = self.criterion(out, target)\n all_target.append(target.cpu())\n all_pred.append(out.cpu())\n all_loss.append(loss.item())\n all_target = torch.cat(all_target, dim=0)\n all_pred = torch.cat(all_pred, dim=0)",
"score": 63.260456990168834
},
{
"filename": "trainer/self_supervised/fttrans_w_scarf.py",
"retrieved_chunk": " if self.model.train:\n scarf_da = self.scarf_da_train\n else:\n scarf_da = self.scarf_da_val\n if cont is not None:\n cont = scarf_da(cont, \"cont\").to(torch.float)\n if cate is not None:\n cate = scarf_da(cate, \"cate\").to(torch.long)\n return cont, cate\n def forward(self, cont: Optional[Tensor] = None, cate: Optional[Tensor] = None) -> Tuple[None, float]:",
"score": 35.62885075411306
},
{
"filename": "trainer/base.py",
"retrieved_chunk": " self.model = model\n self.optimizer = optimizer\n self.criterion = criterion\n self.epochs = epochs\n self.eval_metric = eval_metric\n self.eval_less_is_better = eval_less_is_better\n self.early_stopping = EarlyStopping(patience)\n self.scheduler = scheduler\n if mixed_fp16:\n self.scaler = GradScaler()",
"score": 35.44407317773069
}
] | python | forward(cont, cate) |
from pathlib import Path
import pytest
import torch
from src.data.mnist_datamodule import MNISTDataModule
@pytest.mark.parametrize("batch_size", [32, 128])
def test_mnist_datamodule(batch_size):
data_dir = "data/"
dm = MNISTDataModule(data_dir=data_dir, batch_size=batch_size)
dm.prepare_data()
assert not dm.data_train and not dm.data_val and not dm.data_test
assert Path(data_dir, "MNIST").exists()
assert Path(data_dir, "MNIST", "raw").exists()
dm.setup()
assert dm.data_train and dm.data_val and dm.data_test
assert dm. | train_dataloader() and dm.val_dataloader() and dm.test_dataloader() |
num_datapoints = len(dm.data_train) + len(dm.data_val) + len(dm.data_test)
assert num_datapoints == 70_000
batch = next(iter(dm.train_dataloader()))
x, y = batch
assert len(x) == batch_size
assert len(y) == batch_size
assert x.dtype == torch.float32
assert y.dtype == torch.int64
| tests/test_datamodules.py | janghyuk-choi-slot-attention-lightning-2993443 | [
{
"filename": "src/data/mnist_datamodule.py",
"retrieved_chunk": " careful not to execute things like random split twice!\n \"\"\"\n # load and split datasets only if not loaded already\n if not self.data_train and not self.data_val and not self.data_test:\n trainset = MNIST(self.hparams.data_dir, train=True, transform=self.transforms)\n testset = MNIST(self.hparams.data_dir, train=False, transform=self.transforms)\n dataset = ConcatDataset(datasets=[trainset, testset])\n self.data_train, self.data_val, self.data_test = random_split(\n dataset=dataset,\n lengths=self.hparams.train_val_test_split,",
"score": 81.34715992044035
},
{
"filename": "src/data/mnist_datamodule.py",
"retrieved_chunk": " return 10\n def prepare_data(self):\n \"\"\"Download data if needed.\n Do not use it to assign state (self.x = y).\n \"\"\"\n MNIST(self.hparams.data_dir, train=True, download=True)\n MNIST(self.hparams.data_dir, train=False, download=True)\n def setup(self, stage: Optional[str] = None):\n \"\"\"Load data. Set variables: `self.data_train`, `self.data_val`, `self.data_test`.\n This method is called by lightning with both `trainer.fit()` and `trainer.test()`, so be",
"score": 69.81515725614896
},
{
"filename": "src/data/ptr_datamodule.py",
"retrieved_chunk": " This method is called by lightning with both `trainer.fit()` and `trainer.test()`, so be\n careful not to execute things like random split twice!\n \"\"\"\n self.data_train = PTR(\n data_dir=self.hparams.data_dir,\n img_size=self.hparams.img_size,\n transform=self.transforms,\n train=True,\n )\n self.data_val = PTR(",
"score": 51.5511634076609
},
{
"filename": "src/data/movi_datamodule.py",
"retrieved_chunk": " This method is called by lightning with both `trainer.fit()` and `trainer.test()`, so be\n careful not to execute things like random split twice!\n \"\"\"\n self.data_train = MOVi(\n data_dir=self.hparams.data_dir,\n img_size=self.hparams.img_size,\n transform=self.transforms,\n train=True,\n )\n self.data_val = MOVi(",
"score": 51.5511634076609
},
{
"filename": "src/data/clevrtex_datamodule.py",
"retrieved_chunk": " This method is called by lightning with both `trainer.fit()` and `trainer.test()`, so be\n careful not to execute things like random split twice!\n \"\"\"\n self.data_train = CLEVRTEX(\n data_dir=self.hparams.data_dir,\n img_size=self.hparams.img_size,\n transform=self.transforms,\n train=True,\n )\n self.data_val = CLEVRTEX(",
"score": 51.5511634076609
}
] | python | train_dataloader() and dm.val_dataloader() and dm.test_dataloader() |
from datetime import date
from pathlib import Path
from blurry.sitemap import generate_sitemap_for_file_data_list
from blurry.types import MarkdownFileData
blog_path = Path("blog")
directory_file_data = [
MarkdownFileData(
front_matter=dict(datePublished=date(2021, 1, 1), url="/blog/a-post-1/"),
body="",
path=blog_path / "a-post-1",
),
MarkdownFileData(
front_matter=dict(datePublished=date(2021, 3, 1), url="/blog/b-post-3/"),
body="",
path=blog_path / "b-post-3",
),
MarkdownFileData(
front_matter=dict(dateCreated=date(2021, 2, 1), url="/blog/c-post-2/"),
body="",
path=blog_path / "c-post-2",
),
MarkdownFileData(
front_matter=dict(
dateCreated=date(2022, 1, 10),
dateModified=date(2022, 1, 13),
url="/blog/c-post-4/",
),
body="",
path=blog_path / "c-post-4",
),
]
def test_generate_sitemap_for_file_data_list():
sitemap_content = generate_sitemap_for_file_data_list(
file_data_list=directory_file_data
)
assert sitemap_content.startswith('<?xml version="1.0" encoding="UTF-8"?>')
assert sitemap_content. | endswith("</urlset>") |
assert (
"<url><loc>/blog/c-post-4/</loc><lastmod>2022-01-13</lastmod></url>"
in sitemap_content
)
| tests/test_sitemap.py | blurry-dev-blurry-1d20aad | [
{
"filename": "blurry/sitemap.py",
"retrieved_chunk": "from pathlib import Path\nfrom blurry.settings import get_build_directory\nfrom blurry.types import MarkdownFileData\nSITEMAP_TEMPLATE = \"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xsi:schemaLocation=\"http://www.sitemaps.org/schemas/sitemap/0.9\n http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd\"\n xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\"\n>",
"score": 24.289183247168538
},
{
"filename": "tests/test_utils.py",
"retrieved_chunk": " file_data = sorted_directory_file_data[blog_path]\n assert \"post-3\" in str(file_data[0].path)\n assert \"post-2\" in str(file_data[1].path)\n assert \"post-1\" in str(file_data[2].path)\n assert \"post-4\" in str(file_data[3].path)\[email protected](\n \"path, expected_url\",\n [\n (Path(\"index.md\"), \"https://a.com/\"),\n (Path(\"contact.md\"), \"https://a.com/contact/\"),",
"score": 24.226486507712146
},
{
"filename": "tests/test_utils.py",
"retrieved_chunk": " path=Path(\"c-post-2\"),\n ),\n MarkdownFileData(\n front_matter=dict(),\n body=\"\",\n path=Path(\"c-post-4\"),\n ),\n ]\n }\n sorted_directory_file_data = sort_directory_file_data_by_date(directory_file_data)",
"score": 23.91647351932257
},
{
"filename": "tests/test_utils.py",
"retrieved_chunk": "def test_convert_content_path_to_html_path(path_in, expected_html_path):\n html_path = convert_relative_path_in_markdown_to_relative_build_path(path_in)\n assert html_path == expected_html_path\ndef test_sort_directory_file_data_by_date():\n blog_path = Path(\"blog\")\n directory_file_data = {\n blog_path: [\n MarkdownFileData(\n front_matter=dict(datePublished=date(2021, 1, 1)),\n body=\"\",",
"score": 17.637460613569516
},
{
"filename": "blurry/sitemap.py",
"retrieved_chunk": " BUILD_DIR = get_build_directory()\n file_data = []\n for file_data_list in file_data_by_directory.values():\n file_data.extend(file_data_list)\n sitemap = generate_sitemap_for_file_data_list(file_data)\n sitemap_path = BUILD_DIR / \"sitemap.xml\"\n sitemap_path.write_text(sitemap)",
"score": 13.819075541694769
}
] | python | endswith("</urlset>") |
import dataclasses
import pprint
import time
from functools import partial
import json
from multiprocessing import Pool
import h5py
import bpt.tools.utils as utils
from ml_collections.config_dict import config_dict
from ml_collections import ConfigDict
from tqdm import tqdm, trange
import numpy as np
from datasets import load_dataset
class TextProcessor(object):
""" Example processor that converts a dictionary of texts into tokens. """
@staticmethod
def get_default_config(updates=None):
config = ConfigDict()
config.fields_from_example = ''
config.fields = ''
config.subfield_separator = ' '
config.add_eos_token = True
config.prepend_text = ''
if updates is not None:
config.update(ConfigDict(updates).copy_and_resolve_references())
return config
def __init__(self, config, tokenizer):
self.config = self.get_default_config(config)
assert self.config.fields != '' or self.config.fields_from_example != '', (
'Either fields or fields_from_example must be specified.'
)
self.tokenizer = tokenizer
def __call__(self, example, has_aux=False):
if has_aux:
example, *aux = example
else:
aux = tuple()
token_buffer = []
loss_mask_buffer = []
if self.config.fields_from_example != '':
fields = example[self.config.fields_from_example].split(',')
else:
fields = self.config.fields.split(',')
for i, field in enumerate(fields):
if field.startswith('[') and field.endswith(']'):
# No loss for this field.
field = field[1:-1]
mask = 0.0
else:
mask = 1.0
if field == '<|bos|>':
token_buffer.append(self.tokenizer.bos_token_id)
loss_mask_buffer.append(mask)
elif field == '<|eos|>':
token_buffer.append(self.tokenizer.eos_token_id)
loss_mask_buffer.append(mask)
else:
subfields = field.split('+')
text = self.config.subfield_separator.join(
[example[subfield] for subfield in subfields]
)
if i == 0:
text = self.config.prepend_text + text
tokens = self.tokenizer.encode(text)
token_buffer.extend(tokens)
loss_mask_buffer.extend([mask for _ in range(len(tokens))])
if self.config.add_eos_token:
token_buffer.append(self.tokenizer.eos_token_id)
loss_mask_buffer.append(1.0)
return token_buffer, loss_mask_buffer, *aux
class Dataset(object):
@staticmethod
def get_default_config(updates=None):
config = ConfigDict()
config.path = ''
config.seq_length = 1024
config.batch_size = 8
config.start_seek_loc = 0
config.index_at_start = 0
config.tokenizer_processes = 1
config.tokenizer_parallel_chunk_size = 32
config.tokenizer_parallel_batch_size = 1024
if updates is not None:
config.update(ConfigDict(updates).copy_and_resolve_references())
return config
def __init__(self, config, tokenizer, text_processor):
self.config = self.get_default_config(config)
assert self.config.path != ''
self._tokenizer = tokenizer
self._text_processor = text_processor
self._index = self.config.index_at_start
self._file_loc = self.config.start_seek_loc
self._n_batch = 0
def parse_json(self, line):
if not line or line == '\n':
return None
try:
data = json.loads(line)
except json.decoder.JSONDecodeError:
print(f'Error parsing json line:\n{line}')
return None
return data
def json_iterator(self):
with utils. | open_file(self.config.path, 'r') as fin: |
fin.seek(self._file_loc)
while True:
line = fin.readline()
self._file_loc = fin.tell()
if not line: # Reached EOF
self._index = 0
fin.seek(0)
continue
data = self.parse_json(line)
if data is not None:
# JSON parsing succeeded
yield data, self._file_loc, self._index
self._index += 1
def batched(self, iterator, batch_size):
batch = []
for example in iterator:
batch.append(example)
if len(batch) == batch_size:
yield batch
batch = []
if len(batch) > 0:
yield batch
def parallel_example_iterator(self):
if self.config.tokenizer_processes == 1:
for example, loc, index in self.json_iterator():
yield self.text_processor((example, loc, index), has_aux=True)
else:
process_pool = Pool(self.config.tokenizer_processes)
batched_iterator = self.batched(
self.json_iterator(), self.config.tokenizer_parallel_batch_size
)
with process_pool as pool:
map_fn = partial(self.text_processor, has_aux=True)
next_batch = pool.map_async(
map_fn, next(batched_iterator),
chunksize=self.config.tokenizer_parallel_chunk_size
)
while True:
current_batch = next_batch
next_batch = pool.map_async(
map_fn, next(batched_iterator),
chunksize=self.config.tokenizer_parallel_chunk_size
)
for example in current_batch.get():
yield example
def __iter__(self):
chunk_size = self.config.batch_size * self.config.seq_length
token_buffer = []
loss_mask_buffer = []
total_tokens = 0
last_time = 0.0
for tokens, loss_masks, loc, index in self.parallel_example_iterator():
token_buffer.extend(tokens)
loss_mask_buffer.extend(loss_masks)
while len(token_buffer) > chunk_size + 1:
total_tokens += chunk_size
metrics = {
'dataset_file_loc': loc,
'dataset_example_index': index,
'dataset_total_tokens': total_tokens,
'dataset_throughput_tps': chunk_size / (time.time() - last_time),
}
last_time = time.time()
input_tokens = np.array(token_buffer[:chunk_size], dtype=np.int32)
output_tokens = np.array(token_buffer[1:chunk_size+1], dtype=np.int32)
# reshape to batch_size x seq_length
input_tokens = input_tokens.reshape(self.config.batch_size, -1)
output_tokens = output_tokens.reshape(self.config.batch_size, -1)
loss_masks = np.array(loss_mask_buffer[:chunk_size], dtype=np.float32).reshape(self.config.batch_size, -1)
yield {
"input_tokens": input_tokens,
"output_tokens": output_tokens,
"loss_masks": loss_masks,
}, metrics
token_buffer = token_buffer[chunk_size:]
loss_mask_buffer = loss_mask_buffer[chunk_size:]
def val_iter(self):
chunk_size = self.config.batch_size * self.config.seq_length
token_buffer = []
loss_mask_buffer = []
total_tokens = 0
last_time = 0.0
for tokens, loss_masks, loc, index in self.parallel_example_iterator():
token_buffer.extend(tokens)
loss_mask_buffer.extend(loss_masks)
while len(token_buffer) > chunk_size + 1:
total_tokens += chunk_size
metrics = {
'dataset_file_loc': loc,
'dataset_example_index': index,
'dataset_total_tokens': total_tokens,
'dataset_throughput_tps': chunk_size / (time.time() - last_time),
}
last_time = time.time()
input_tokens = np.array(token_buffer[:chunk_size], dtype=np.int32)
output_tokens = np.array(token_buffer[1:chunk_size+1], dtype=np.int32)
# reshape to batch_size x seq_length
input_tokens = input_tokens.reshape(self.config.batch_size, -1)
output_tokens = output_tokens.reshape(self.config.batch_size, -1)
loss_masks = np.array(loss_mask_buffer[:chunk_size], dtype=np.float32).reshape(self.config.batch_size, -1)
yield {
"input_tokens": input_tokens,
"output_tokens": output_tokens,
"loss_masks": loss_masks,
}, metrics
token_buffer = token_buffer[chunk_size:]
loss_mask_buffer = loss_mask_buffer[chunk_size:]
def get_state_dict(self):
return dict(
config=self.config,
index=self._index,
file_loc=self._file_loc,
)
def load_state_dict(self, state_dict):
self.config = state_dict.get('config', self.config)
self._index = state_dict.get('index', self.config.index_at_start)
self._file_loc = state_dict.get('file_loc', self.config.start_seek_loc)
@property
def seq_length(self):
return self.config.seq_length
@property
def tokenizer(self):
return self._tokenizer
@property
def text_processor(self):
return self._text_processor
@property
def vocab_size(self):
return len(self.tokenizer)
| blockwise-parallel-transformer/bpt/data.py | kyegomez-Blockwise-Parallel-Transformer-f849b04 | [
{
"filename": "blockwise-parallel-transformer/bpt/model.py",
"retrieved_chunk": " elif load_type == 'json':\n with open_file(load_path, 'r') as fin:\n raw_config = fin.read()\n return cls.from_dict(json.loads(raw_config))\n elif load_type == 'huggingface':\n return cls.from_pretrained(load_path)\n else:\n raise ValueError(f'Unsupported load config type: {load_type}')\nlogger = logging.get_logger(__name__)\n_CHECKPOINT_FOR_DOC = \"gpt\"",
"score": 52.810088091068465
},
{
"filename": "blockwise-parallel-transformer/bpt/tools/utils.py",
"retrieved_chunk": " with open_file(path, \"rb\") as fin:\n data = pickle.load(fin)\n return data\ndef text_to_array(text, encoding=\"utf-8\"):\n return np.frombuffer(text.encode(encoding), dtype=\"uint8\")\ndef array_to_text(array, encoding=\"utf-8\"):\n with BytesIO(array) as fin:\n text = fin.read().decode(encoding)\n return text\nclass JaxRNG(object):",
"score": 36.67368276972326
},
{
"filename": "blockwise-parallel-transformer/bpt/tools/checkpoint.py",
"retrieved_chunk": " with utils.open_file(path, \"rb\") as fin:\n encoded_bytes = fin.read()\n state_dict = flax.serialization.msgpack_restore(encoded_bytes)\n if shard_fns is not None:\n shard_fns = to_state_dict(shard_fns)\n state_dict = tree_apply(shard_fns, state_dict)\n if target is None:\n return state_dict\n return from_state_dict(target, state_dict)\n @classmethod",
"score": 28.472085877530965
},
{
"filename": "blockwise-parallel-transformer/bpt/tools/checkpoint.py",
"retrieved_chunk": " with utils.open_file(path) as fin:\n # 83886080 bytes = 80 MB, which is 16 blocks on GCS\n unpacker = msgpack.Unpacker(fin, read_size=83886080, max_buffer_size=0)\n for key, value in unpacker:\n key = tuple(key)\n if remove_dict_prefix is not None:\n if key[:len(remove_dict_prefix)] == remove_dict_prefix:\n key = key[len(remove_dict_prefix):]\n else:\n continue",
"score": 22.95762503291436
},
{
"filename": "blockwise-parallel-transformer/bpt/tools/jax_utils.py",
"retrieved_chunk": " return output\ndef named_tree_map(f, tree, *rest, is_leaf=None, sep=None):\n \"\"\" An extended version of jax.tree_util.tree_map, where the mapped function\n f takes both the name (path) and the tree leaf as input.\n \"\"\"\n return jax.tree_util.tree_map_with_path(\n lambda path, x, *r: f(tree_path_to_string(path, sep=sep), x, *r),\n tree, *rest,\n is_leaf=is_leaf\n )",
"score": 22.375994731306296
}
] | python | open_file(self.config.path, 'r') as fin: |
import paramiko
import time
import socket
from func_timeout import func_set_timeout
from utils.lat_parser import LatParser
from utils.color_printer import print_OK, print_FAIL
BUFFER_SIZE = 16 * 1024 * 1024
END_PROMPT = '[END]'
OOM_PROMPT = 'shared memory space run out'
DEADLOCK_PROMPT = 'Deadlock'
class CMDManager(object):
def __init__(self, cluster_ips: list, master_ip: str):
super().__init__()
self.__cluster_ips = cluster_ips
self.__master_idx = cluster_ips.index(master_ip)
self.__CNs = [self.__get_ssh_CNs(hostname) for hostname in cluster_ips]
self.__shells = [cli.invoke_shell() for cli in self.__CNs]
for shell in self.__shells:
shell.setblocking(False)
self.__clear_shell(shell)
self.__lat_parser = LatParser(self.__CNs)
def __del__(self):
for cli in self.__CNs:
cli.close()
def __clear_shell(self, shell):
shell.send('\n')
while True:
try:
shell.recv(BUFFER_SIZE)
break
except socket.timeout:
continue
def __match_prompt(self, content: str, end: str):
if end in content:
return True
return False
def __get_ssh_CNs(self, hostname: str):
port = 22
cli = paramiko.SSHClient()
cli.set_missing_host_key_policy(paramiko.AutoAddPolicy())
cli.connect(hostname, port, compress=True)
return cli
@func_set_timeout(60)
def all_execute(self, command: str, CN_num: int = -1):
if CN_num < 0: # -1 means use all CNs
CN_num = len(self.__CNs)
outs = {}
errs = {}
stdouts = {}
stderrs = {}
print_OK(f'COMMAND="{command}"')
print_OK(f'EXECUTE_IPs={self.__cluster_ips[:CN_num]}')
for i in range(CN_num):
cli_ip = self.__cluster_ips[i]
_, stdouts[cli_ip], stderrs[cli_ip] = self.__CNs[i].exec_command(command, get_pty=True)
for i in range(CN_num):
cli_ip = self.__cluster_ips[i]
outs[cli_ip] = stdouts[cli_ip].readlines() # block here
errs[cli_ip] = stderrs[cli_ip].readlines() # TODO: Retry
for line in outs[cli_ip]:
print(f'[CN {cli_ip} OUTPUT] {line.strip()}')
for line in errs[cli_ip]:
print_FAIL(f'[CN {cli_ip} ERROR] {line.strip()}')
return outs
def one_execute(self, command: str):
# one of the nodes (i.e., master node) will do some special task
cli = self.__CNs[self.__master_idx]
cli_ip = self.__cluster_ips[self.__master_idx]
print_OK(f'COMMAND="{command}"')
print_OK(f'EXECUTE_IP={cli_ip}')
try:
_, stdout, stderr = cli.exec_command(command, get_pty=True)
out = stdout.readlines() # block here
err = stderr.readlines()
for line in out:
print(f'[CN {cli_ip} OUTPUT] {line.strip()}')
for line in err:
print_FAIL(f'[CN {cli_ip} OUTPUT] {line.strip()}')
except:
print_FAIL(f'[CN {cli_ip}] FAILURE: {command}')
return out
@func_set_timeout(600)
def all_long_execute(self, command: str, CN_num: int = -1):
if CN_num < 0: # -1 means use all CNs
CN_num = len(self.__CNs)
print_OK(f'COMMAND="{command}"')
print_OK(f'EXECUTE_IPs={self.__cluster_ips[:CN_num]}')
if not command.endswith('\n'):
command += '\n'
for i in range(CN_num):
self.__shells[i].send(command)
for i in range(CN_num):
while not self.__shells[i].recv_ready():
time.sleep(0.2)
outs = {self.__cluster_ips[i]: '' for i in range(CN_num)}
for i in range(CN_num):
cli_ip = self.__cluster_ips[i]
while not self.__match_prompt(outs[cli_ip], END_PROMPT):
try:
msg = self.__shells[i].recv(BUFFER_SIZE).decode()
if msg:
print(f'[CN {cli_ip} OUTPUT] {msg.strip()}')
outs[cli_ip] += msg
if self.__match_prompt(outs[cli_ip], OOM_PROMPT):
raise Exception(OOM_PROMPT)
if self.__match_prompt(outs[cli_ip], DEADLOCK_PROMPT):
raise Exception(DEADLOCK_PROMPT)
except socket.timeout:
continue
for ip in outs.keys():
outs[ip] = outs[ip].strip().split('\n')
return outs
def get_cluster_lats(self, lat_dir_path: str, CN_num: int, target_epoch: int, get_avg: bool=False):
if get_avg:
start_epoch = max(target_epoch // 2, target_epoch - 4)
p50_p99_lats = self.__lat_parser. | load_remote_lats(lat_dir_path, CN_num, start_epoch, target_epoch - start_epoch + 1) |
assert(p50_p99_lats)
p50s, p99s = zip(*list(p50_p99_lats.values()))
p50 = sum(p50s) / len(p50s)
p99 = sum(p99s) / len(p99s)
else:
p50, p99 = self.__lat_parser.load_remote_lats(lat_dir_path, CN_num, target_epoch, 1)[target_epoch] # to save time, we simply use the latency result in one epoch
assert(p50 is not None and p99 is not None)
return p50, p99
| exp/utils/cmd_manager.py | dmemsys-SMART-dc4de6f | [
{
"filename": "exp/utils/log_parser.py",
"retrieved_chunk": " start_epoch = max(target_epoch // 2, target_epoch - 4)\n cnt = start_epoch\n for line in log:\n if f\"epoch {start_epoch} passed!\" in line:\n flag = True\n elif flag and \"cluster throughput\" in line:\n tpt.append(float(line.strip().split(' ')[2]))\n elif flag and \"cache hit rate\" in line:\n data = line.strip().split(' ')[3]\n if data.replace('.', '').isdigit():",
"score": 55.813931997406826
},
{
"filename": "exp/utils/log_parser.py",
"retrieved_chunk": "from typing import Optional\nfrom utils.color_printer import print_FAIL\nclass LogParser(object):\n def __init__(self):\n pass\n def get_statistics(self, logs: dict, target_epoch: int, get_avg: bool=False):\n for log in logs.values():\n if get_avg:\n tpt, cache_hit_rate, lock_fail_cnt, leaf_invalid_rate = self.__parse_log_avg(log, target_epoch)\n else:",
"score": 40.54468056614323
},
{
"filename": "exp/utils/lat_parser.py",
"retrieved_chunk": "from typing import List\nfrom pathlib import Path\nimport paramiko\nclass LatParser(object):\n def __init__(self, clients: List[paramiko.SSHClient]):\n self.__sftps = [cli.open_sftp() for cli in clients]\n self.__lat_cnt = dict()\n def load_remote_lats(self, lat_dir_path: str, CN_num: int, epoch_start: int = 1, epoch_num: int = 10):\n p50_p99_lats = {}\n for e_id in range(epoch_start, epoch_start + epoch_num):",
"score": 37.936227176934814
},
{
"filename": "exp/utils/log_parser.py",
"retrieved_chunk": " if cnt == target_epoch:\n break\n def get_avg(l):\n return sum(l) / len(l) if l else 0\n return get_avg(tpt) if tpt else None, get_avg(cache_hit_rate), get_avg(lock_fail_cnt), get_avg(leaf_invalid_rate)\n def get_redundant_statistics(self, log):\n redundant_read, redundant_write, redundant_cas = None, None, None\n flag = False\n for line in log:\n if \"Calculation done!\" in line:",
"score": 33.76024697266678
},
{
"filename": "exp/utils/lat_parser.py",
"retrieved_chunk": " self.__lat_cnt.clear()\n for sftp in self.__sftps[:CN_num]:\n remote_file = sftp.open(str(Path(lat_dir_path) / f'epoch_{e_id}.lat'))\n try:\n for line in remote_file:\n lat, cnt = line.strip().split('\\t', 1)\n if int(cnt):\n if lat not in self.__lat_cnt:\n self.__lat_cnt[lat] = 0\n self.__lat_cnt[lat] += int(cnt)",
"score": 33.35658148911832
}
] | python | load_remote_lats(lat_dir_path, CN_num, start_epoch, target_epoch - start_epoch + 1) |
from datetime import date
from pathlib import Path
from blurry.sitemap import generate_sitemap_for_file_data_list
from blurry.types import MarkdownFileData
blog_path = Path("blog")
directory_file_data = [
MarkdownFileData(
front_matter=dict(datePublished=date(2021, 1, 1), url="/blog/a-post-1/"),
body="",
path=blog_path / "a-post-1",
),
MarkdownFileData(
front_matter=dict(datePublished=date(2021, 3, 1), url="/blog/b-post-3/"),
body="",
path=blog_path / "b-post-3",
),
MarkdownFileData(
front_matter=dict(dateCreated=date(2021, 2, 1), url="/blog/c-post-2/"),
body="",
path=blog_path / "c-post-2",
),
MarkdownFileData(
front_matter=dict(
dateCreated=date(2022, 1, 10),
dateModified=date(2022, 1, 13),
url="/blog/c-post-4/",
),
body="",
path=blog_path / "c-post-4",
),
]
def test_generate_sitemap_for_file_data_list():
sitemap_content = generate_sitemap_for_file_data_list(
file_data_list=directory_file_data
)
assert sitemap_content. | startswith('<?xml version="1.0" encoding="UTF-8"?>') |
assert sitemap_content.endswith("</urlset>")
assert (
"<url><loc>/blog/c-post-4/</loc><lastmod>2022-01-13</lastmod></url>"
in sitemap_content
)
| tests/test_sitemap.py | blurry-dev-blurry-1d20aad | [
{
"filename": "tests/test_utils.py",
"retrieved_chunk": " path=Path(\"c-post-2\"),\n ),\n MarkdownFileData(\n front_matter=dict(),\n body=\"\",\n path=Path(\"c-post-4\"),\n ),\n ]\n }\n sorted_directory_file_data = sort_directory_file_data_by_date(directory_file_data)",
"score": 26.330935688254986
},
{
"filename": "blurry/sitemap.py",
"retrieved_chunk": "from pathlib import Path\nfrom blurry.settings import get_build_directory\nfrom blurry.types import MarkdownFileData\nSITEMAP_TEMPLATE = \"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset\n xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n xsi:schemaLocation=\"http://www.sitemaps.org/schemas/sitemap/0.9\n http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd\"\n xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\"\n>",
"score": 21.445952336970578
},
{
"filename": "tests/test_utils.py",
"retrieved_chunk": " file_data = sorted_directory_file_data[blog_path]\n assert \"post-3\" in str(file_data[0].path)\n assert \"post-2\" in str(file_data[1].path)\n assert \"post-1\" in str(file_data[2].path)\n assert \"post-4\" in str(file_data[3].path)\[email protected](\n \"path, expected_url\",\n [\n (Path(\"index.md\"), \"https://a.com/\"),\n (Path(\"contact.md\"), \"https://a.com/contact/\"),",
"score": 21.17271759712175
},
{
"filename": "tests/test_utils.py",
"retrieved_chunk": "def test_convert_content_path_to_html_path(path_in, expected_html_path):\n html_path = convert_relative_path_in_markdown_to_relative_build_path(path_in)\n assert html_path == expected_html_path\ndef test_sort_directory_file_data_by_date():\n blog_path = Path(\"blog\")\n directory_file_data = {\n blog_path: [\n MarkdownFileData(\n front_matter=dict(datePublished=date(2021, 1, 1)),\n body=\"\",",
"score": 17.637460613569516
},
{
"filename": "blurry/sitemap.py",
"retrieved_chunk": " BUILD_DIR = get_build_directory()\n file_data = []\n for file_data_list in file_data_by_directory.values():\n file_data.extend(file_data_list)\n sitemap = generate_sitemap_for_file_data_list(file_data)\n sitemap_path = BUILD_DIR / \"sitemap.xml\"\n sitemap_path.write_text(sitemap)",
"score": 13.819075541694769
}
] | python | startswith('<?xml version="1.0" encoding="UTF-8"?>') |
"""REST client handling, including JQuantsStream base class."""
from __future__ import annotations
import sys
import typing as t
from pathlib import Path
from typing import Any, Callable, Iterable
import requests
from singer_sdk.helpers.jsonpath import extract_jsonpath
from singer_sdk.streams import RESTStream
from tap_jquants.auth import JQuantsAuthenticator
from tap_jquants.pagination import JQuantsDatePaginator
if sys.version_info >= (3, 8):
from functools import cached_property
else:
from cached_property import cached_property
from .helpers import convert_json
if t.TYPE_CHECKING:
from singer_sdk.pagination import BaseAPIPaginator
_Auth = Callable[[requests.PreparedRequest], requests.PreparedRequest]
SCHEMAS_DIR = Path(__file__).parent / Path("./schemas")
class JQuantsStream(RESTStream):
"""JQuants stream class."""
@property
def url_base(self) -> str:
"""Return the API URL root, configurable via tap settings."""
return "https://api.jquants.com/v1"
next_page_token_jsonpath = "$.pagination_key" # noqa: S105
@cached_property
def authenticator(self) -> _Auth:
"""Return a new authenticator object.
Returns:
An authenticator instance.
"""
return JQuantsAuthenticator. | create_for_stream(self) |
@property
def http_headers(self) -> dict:
"""Return the http headers needed.
Returns:
A dictionary of HTTP headers.
"""
headers = {}
if "user_agent" in self.config:
headers["User-Agent"] = self.config.get("user_agent")
return headers
def get_url_params(
self,
_context: dict | None,
next_page_token: Any | None,
) -> dict[str, Any]:
"""Return a dictionary of values to be used in URL parameterization.
Args:
context: The stream context.
next_page_token: The next page index or value.
Returns:
A dictionary of URL query parameters.
"""
params: dict = {}
if next_page_token:
params["pagination_key"] = next_page_token
return params
def parse_response(self, response: requests.Response) -> Iterable[dict]:
"""Parse the response and return an iterator of result records.
Args:
response: The HTTP ``requests.Response`` object.
Yields:
Each record from the source.
"""
yield from extract_jsonpath(
self.records_jsonpath,
input=convert_json(response.json()),
)
class JQuantsDateStream(JQuantsStream):
"""JQuants incremental stream class based on date."""
def get_new_paginator(self) -> BaseAPIPaginator:
"""Return a new paginator object."""
return JQuantsDatePaginator()
def get_url_params(
self,
context: dict | None,
next_page_token: Any | None,
) -> dict[str, Any]:
"""Return a dictionary of parameters to use in the URL."""
params: dict = {}
if next_page_token is not None:
date_key, pagination_key = next_page_token
if pagination_key:
params["pagination_key"] = next_page_token
params["date"] = date_key
else:
starting_date = self.get_starting_timestamp(context)
if starting_date:
params["date"] = starting_date.strftime("%Y-%m-%d")
self.logger.info("URL params: %s", params)
return params
class JQuantsFromStream(JQuantsStream):
"""JQuants incremental stream class based on from."""
def get_url_params(
self,
context: dict | None,
next_page_token: Any | None,
) -> dict[str, Any]:
"""Return a dictionary of parameters to use in the URL."""
params: dict = {}
if next_page_token is not None:
pagination_key = next_page_token
if pagination_key:
params["pagination_key"] = next_page_token
starting_date = self.get_starting_timestamp(context)
if starting_date:
params["from"] = starting_date.strftime("%Y-%m-%d")
self.logger.info("URL params: %s", params)
return params
| tap_jquants/client.py | stn-tap-jquants-336373c | [
{
"filename": "tap_jquants/auth.py",
"retrieved_chunk": " stream: JQuantsStream,\n ) -> JQuantsAuthenticator:\n \"\"\"Instantiate an authenticator for a specific Singer stream.\n Args:\n stream: The Singer stream instance.\n Returns:\n A new authenticator.\n \"\"\"\n with requests.Session() as session:\n id_token = cls._get_id_token(stream, session)",
"score": 28.266665620683142
},
{
"filename": "tap_jquants/tap.py",
"retrieved_chunk": " ).to_dict()\n def discover_streams(self) -> list[JQuantsStream]:\n \"\"\"Return a list of discovered streams.\n Returns:\n A list of discovered streams.\n \"\"\"\n return [\n streams.AnnouncementStream(self),\n streams.BreakdownStream(self),\n streams.DailyQuotesStream(self),",
"score": 18.739229747066418
},
{
"filename": "tap_jquants/auth.py",
"retrieved_chunk": " headers={\n \"Content-Type\": \"application/json\",\n },\n )\n if response.status_code != requests.codes.ok:\n raise JQuantsError(response)\n return response.json()[\"idToken\"]\n @classmethod\n def create_for_stream(\n cls: type[JQuantsAuthenticator],",
"score": 10.971994570117987
},
{
"filename": "tap_jquants/pagination.py",
"retrieved_chunk": " \"\"\"Create a new paginator.\n Args:\n args: Paginator positional arguments for base class.\n kwargs: Paginator keyword arguments for base class.\n \"\"\"\n super().__init__(None, *args, **kwargs)\n def get_next(self, response: Response) -> tuple[str, str | None] | None:\n \"\"\"Get the next page token.\n Args:\n response: API response object.",
"score": 9.8782876692827
},
{
"filename": "tap_jquants/pagination.py",
"retrieved_chunk": " extract_jsonpath(PAGINATOR_JSONPATH, response.json()),\n None,\n )\n if pagination_key is not None:\n return date_key, pagination_key\n date_key = get_next_date(date_key)\n if date_key is None:\n return None\n return date_key, None",
"score": 9.519973039708464
}
] | python | create_for_stream(self) |
from pathlib import Path
import json
from utils.pic_line_drawer import LineDrawer
from utils.pic_bar_drawer import BarDrawer
from utils.color_printer import print_OK
class PicGenerator(object):
def __init__(self, data_path: str, style_path: str):
self.__data_path = data_path
self.__style_path = style_path
self.__ld = LineDrawer(data_path)
self.__bd = BarDrawer(data_path)
self.__figs_type = {
'3a' : 'line_one_ax', '3b' : 'bar_one_ax' , '3c' : 'line_one_ax' , '3d' : 'line_one_ax',
'4a' : 'line_two_ax', '4b' : 'bar_two_ax' , '4c' : 'line_one_ax' , '4d' : 'line_two_ax',
'11a': 'line_one_ax', '11b': 'line_one_ax' , '11c': 'line_one_ax' , '11d': 'line_one_ax', '11e': 'line_one_ax' ,
'12a': 'line_one_ax', '12b': 'line_one_ax' , '12c': 'line_one_ax' , '12d': 'line_one_ax', '12e': 'line_one_ax' ,
'13' : 'line_one_ax', '14' : 'bar_with_line', '15' : 'bar_with_line', '16' : 'bar_two_ax' , '17' : 'bar_with_line',
'18a': 'line_one_ax', '18b': 'line_one_ax' , '18c': 'line_one_ax'
}
self.__axhlineColor = '#00007c'
self.__linewidth = 0.8
self.__font_size = 15
def __aux_plt(self, ax):
ax.axhline(y=45, ls=(0, (5, 3)), c=self.__axhlineColor, lw=self.__linewidth)
ax.text(200, 47, 'IOPS Upper Bound', fontsize=self.__font_size-1, color=self.__axhlineColor)
ax.axhline(y=7, ls=(0, (5, 3)), c=self.__axhlineColor, lw=self.__linewidth)
ax.text(120, 9, 'Bandwidth Bottleneck', fontsize=self.__font_size-1, color=self.__axhlineColor)
def __annotation(self, ax):
ax.annotate('', xy=(4, 14), xytext=(40, 14), arrowprops=dict(arrowstyle="<->", color=self.__axhlineColor, ls=(0, (5, 3))), fontsize=self.__font_size-1)
ax.text(12.5, 16, '4M vs. 40M', fontsize=self.__font_size-1, color=self.__axhlineColor)
def generate(self, fig_num: str):
fig_name = f"fig_{fig_num}.pdf"
fig_type = self.__figs_type[fig_num]
# load data
with (Path(self.__data_path) / f'fig_{fig_num}.json').open(mode='r') as f:
data = json.load(f)
# load style
with (Path(self.__style_path) / f'fig_{fig_num}.json').open(mode='r') as f:
custom_style = json.load(f)
# load func
if fig_num == '3c':
custom_style['aux_plt_func'] = self.__aux_plt
if fig_num == '3d':
custom_style['aux_plt_func'] = self.__annotation
# draw
if fig_type == 'line_one_ax':
self.__ld. | plot_with_one_ax(data, fig_name, custom_style=custom_style) |
elif fig_type == 'line_two_ax':
self.__ld.plot_with_two_ax(data, fig_name, custom_style=custom_style)
elif fig_type == 'bar_one_ax':
self.__bd.plot_with_one_ax(data, fig_name, custom_style=custom_style)
elif fig_type == 'bar_two_ax':
self.__bd.plot_with_two_ax(data, fig_name, custom_style=custom_style)
elif fig_type == 'bar_with_line':
self.__bd.plot_with_line(data, fig_name, custom_style=custom_style)
print_OK(f"Draw {fig_name} done!")
| exp/utils/pic_generator.py | dmemsys-SMART-dc4de6f | [
{
"filename": "exp/utils/pic_line_drawer.py",
"retrieved_chunk": " # func\n self.aux_plt_func = None\n self.annotation_func = None\n def plot_with_one_ax(self, data: dict, fig_name: str, custom_style: dict = {}, method_legend: dict = {}):\n self.__load_default_style()\n # load custom style\n for k, v in custom_style.items():\n setattr(self, k, v)\n fig, ax = plt.subplots(1, 1, figsize=self.figsize, dpi=300)\n if self.hide_half_edge:",
"score": 57.50620377108288
},
{
"filename": "exp/utils/pic_bar_drawer.py",
"retrieved_chunk": " self.yR_scale = ''\n # label\n self.x_label = ''\n self.y_label = ''\n self.yL_label = ''\n self.yR_label = ''\n # func\n self.aux_plt_func = None\n self.annotation_func = None\n def plot_with_one_ax(self, data: dict, fig_name: str, custom_style: dict = {}, method_legend: dict = {}):",
"score": 53.93946583823057
},
{
"filename": "exp/utils/pic_line_drawer.py",
"retrieved_chunk": " ax.legend(legend_handles, legend_labels, fontsize=self.legend_size, loc=self.legend_location, frameon=False, ncol=self.legend_ncol) # labelspacing=0.1\n if self.aux_plt_func:\n self.aux_plt_func(ax)\n plt.savefig(str(Path(self.pic_dir) / fig_name), format='pdf', bbox_inches='tight')\n plt.close()\n def plot_with_two_ax(self, data: dict, fig_name: str, custom_style: dict = {}, method_legend: dict = {}, method_ax: dict = {}):\n self.__load_default_style()\n # load custom style\n for k, v in custom_style.items():\n setattr(self, k, v)",
"score": 47.780713039679895
},
{
"filename": "exp/utils/pic_bar_drawer.py",
"retrieved_chunk": " ax_R.legend(fontsize=self.legend_size, loc=self.legendR_location, frameon=False)\n if self.yRfloat:\n ax_R.yaxis.set_major_formatter(FormatStrFormatter('%.2f'))\n if self.aux_plt_func:\n self.aux_plt_func(ax)\n plt.savefig(str(Path(self.pic_dir) / fig_name), format='pdf', bbox_inches='tight')\n plt.close()\n def plot_with_line(self, data: dict, fig_name: str, custom_style: dict = {}, method_legend: dict = {}, method_ax: dict = {}):\n self.__load_default_style()\n # load custom style",
"score": 43.82822209358736
},
{
"filename": "exp/utils/pic_bar_drawer.py",
"retrieved_chunk": " def plot_with_two_ax(self, data: dict, fig_name: str, custom_style: dict = {}, method_legend: dict = {}, method_ax: dict = {}):\n self.__load_default_style()\n # load custom style\n for k, v in custom_style.items():\n setattr(self, k, v)\n fig, ax_L = plt.subplots(1, 1, figsize=self.figsize, dpi=300)\n methods = data['methods']\n bar_groups = data['bar_groups']\n if not method_legend:\n method_legend = {method: method for method in data['methods']}",
"score": 39.60740468780208
}
] | python | plot_with_one_ax(data, fig_name, custom_style=custom_style) |
import torch
from torch import BoolTensor, FloatTensor, allclose, arange, manual_seed, no_grad, randn
from torch.nn.functional import pad
from muse_maskgit_pytorch.attn.ein_attn import Attention as EinAttn
from muse_maskgit_pytorch.attn.xformers_attn import Attention as XformersAttn
device = torch.device("cuda")
dtype = torch.float32
seed = 42
# realistically this would be 320 in stable-diffusion, but I'm going smaller during testing
vision_dim = 64
attn_init_params = {
"dim": vision_dim,
"dim_head": 64,
# realistically this would be at least 5
"heads": 2,
"cross_attend": True,
"scale": 8,
}
with no_grad():
# seed RNG before we initialize any layers, so that both will end up with same params
manual_seed(seed)
ein_attn = EinAttn(**attn_init_params). | to(device, dtype).eval() |
# commented-out scaled dot product attention because it didn't support flash attn, so we'll try with xformers instead.
# manual_seed(seed)
# sdp_attn = SDPAttn(**attn_init_params).to(device, dtype).eval()
manual_seed(seed)
xfo_attn = XformersAttn(**attn_init_params).to(device, dtype).eval()
batch_size = 2
# realistically this would be 64**2 in stable-diffusion
vision_tokens = 32**2 # 1024
# generate rand on-CPU for cross-platform determinism of results
x: FloatTensor = randn(batch_size, vision_tokens, vision_dim, dtype=dtype).to(device)
# I've said text here simply as an example of something you could cross-attend to
text_tokens = 16 # CLIP would be 77
# for a *general* cross-attention Module:
# kv_in_dim could differ from q_in_dim, but this attention Module requires x and context to have same dim.
text_dim = vision_dim
context: FloatTensor = randn(batch_size, text_tokens, text_dim, dtype=dtype).to(device)
# attend to just the first two tokens in each text condition (e.g. if both were uncond, so [BOS, EOS] followed by PAD tokens)
context_mask: BoolTensor = (arange(text_tokens, device=device) < 2).expand(batch_size, -1).contiguous()
# for xformers cutlassF kernel: masks are only supported for keys whose lengths are multiples of 8:
# https://gist.github.com/Birch-san/0c36d228e1d4b881a06d1c6e5289d569
# so, we add whatever we feel like to the end of the key to extend it to a multiple of 8,
# and add "discard" tokens to the mask to get rid of the excess
# note: muse will add an extra "null" token to our context, so we'll account for that in advance
mask_length = context_mask.shape[-1] + 1
extra_tokens_needed = 8 - (mask_length % 8)
# 0-pad mask to multiple of 8 tokens
xfo_context_mask = pad(context_mask, (0, extra_tokens_needed))
# replicate-pad embedding to multiple of 8 tokens (mask will hide the extra tokens)
xfo_context = pad(context, (0, 0, 0, extra_tokens_needed), "replicate")
ein_result: FloatTensor = ein_attn.forward(x, context, context_mask)
# sdp attn works, but only supports flash attn when context_mask is None.
# with sdp_kernel(enable_math=False):
# sdp_result: FloatTensor = sdp_attn.forward(x, context, context_mask)
xfo_attn: FloatTensor = xfo_attn.forward(x, xfo_context, xfo_context_mask)
# default rtol
rtol = 1e-5
# atol would normally be 1e-8
atol = 5e-7
# assert allclose(ein_result, sdp_result, rtol=rtol, atol=atol), f"looks like attention implementations weren't equivalent, to tolerance rtol={rtol}, atol={atol}"
if not allclose(ein_result, xfo_attn, rtol=rtol, atol=atol):
raise RuntimeError(
f"looks like attention implementations weren't equivalent, to tolerance rtol={rtol}, atol={atol}"
)
| muse_maskgit_pytorch/attn/attn_test.py | Sygil-Dev-muse-maskgit-pytorch-7d7c00c | [
{
"filename": "train_muse_maskgit.py",
"retrieved_chunk": " raise ValueError(\"Can't pass both train_data_dir and dataset_name at the same time!\")\n if accelerator.is_main_process:\n accelerator.print(f\"Preparing MaskGit for training on {accelerator.device.type}\")\n if args.debug:\n inspect(args, docs=False)\n accelerate.utils.set_seed(args.seed)\n # Load the dataset (main process first to download, rest will load from cache)\n with accelerator.main_process_first():\n if args.train_data_dir is not None:\n if args.no_cache:",
"score": 25.3136074604445
},
{
"filename": "muse_maskgit_pytorch/muse_maskgit_pytorch.py",
"retrieved_chunk": " FeedForward(dim=dim, mult=ff_mult),\n ]\n )\n )\n else:\n self.layers.append(\n nn.ModuleList(\n [\n ein_attn.Attention(dim=dim, dim_head=dim_head, heads=heads),\n ein_attn.Attention(dim=dim, dim_head=dim_head, heads=heads, cross_attend=True),",
"score": 24.005424178955288
},
{
"filename": "muse_maskgit_pytorch/attn/xformers_attn.py",
"retrieved_chunk": " def forward(\n self, x: FloatTensor, context: Optional[FloatTensor] = None, context_mask: Optional[BoolTensor] = None\n ):\n assert (context is None) != self.cross_attend\n h = self.heads\n # TODO: you could fuse this layernorm with the linear that follows it, e.g. via TransformerEngine\n x = self.norm(x)\n kv_input = context if self.cross_attend else x\n # TODO: to_q and to_kvs could be combined into one to_qkv\n q, k, v = (self.to_q(x), *self.to_kv(kv_input).chunk(2, dim=-1))",
"score": 20.33344626354483
},
{
"filename": "muse_maskgit_pytorch/attn/sdp_attn.py",
"retrieved_chunk": " def forward(\n self, x: FloatTensor, context: Optional[FloatTensor] = None, context_mask: Optional[BoolTensor] = None\n ):\n assert (context is None) != self.cross_attend\n h = self.heads\n # TODO: you could fuse this layernorm with the linear that follows it, e.g. via TransformerEngine\n x = self.norm(x)\n kv_input = context if self.cross_attend else x\n # TODO: to_q and to_kvs could be combined into one to_qkv\n q, k, v = (self.to_q(x), *self.to_kv(kv_input).chunk(2, dim=-1))",
"score": 20.33344626354483
},
{
"filename": "muse_maskgit_pytorch/trainers/base_accelerated_trainer.py",
"retrieved_chunk": " generator=torch.Generator().manual_seed(seed),\n )\n accelerator.print(\n f\"training with dataset of {len(ds)} samples and validating with randomly splitted {len(valid_ds)} samples\"\n )\n else:\n valid_ds = ds\n accelerator.print(f\"training with shared training and valid dataset of {len(ds)} samples\")\n return ds, valid_ds\n# main trainer class",
"score": 19.286054676674844
}
] | python | to(device, dtype).eval() |
from .yaml_file_manager import YAMLFileManager
from os.path import isfile, join
import os
class UserConfigManager():
"""manager for working with the user_config file."""
USER_CONFIG_TEMPLATE = {
'interface_language': 'English',
'dict_interface_language': None, #example: English: en.yaml
'appearance_mode': 'System', #number from the list system_list_of_appearance_modes
'last_path_to_mods': os.path.expanduser('~\\AppData\\Roaming\\.minecraft\\mods'),
'last_path_to_save': os.path.expanduser('~\\Documents\\translations'),
'startwith': '(Auto)',
}
FILE_NAME = "user_config.yaml"
def __init__(self, main_folder: str) -> None:
#checking for correct input
self._checking_the_path(main_folder)
self.main_folder = main_folder
@staticmethod
def _checking_the_path(folder) -> None:
"""checking the folder path for errors."""
if isinstance(folder, str):
if not os.path.isdir(folder):
raise NotADirectoryError(f"Directory '{folder}' does not exist.")
else:
raise TypeError("Directory must be a string.")
def get_user_config(self, folder_with_translations: str):
"""returns data from the user_config file."""
#checking for correct input
self._checking_the_path(os.path.join(self.main_folder, folder_with_translations))
file_manager = YAMLFileManager(self.main_folder, self.FILE_NAME)
if isfile( join(self.main_folder, self.FILE_NAME) ):
self.user_config = file_manager.load_file()
else:
self.user_config = self.USER_CONFIG_TEMPLATE
self.user_config['dict_interface_language'] = self._get_dictionary_of_interface_language(folder_with_translations)
return self.user_config
def save_user_config(self, data) -> None:
"""writes data to the user_config file."""
file_manager = YAMLFileManager(self.main_folder, self.FILE_NAME)
file_manager.write_to_file(data)
def _get_dictionary_of_interface_language(self, folder_with_translations):
"""return dict_interface_language."""
path_to_folder_with_translations = os.path.join(self.main_folder, folder_with_translations)
manager = YAMLFileManager(path_to_folder_with_translations)
translations_files = manager. | get_yaml_files() |
dict_interface_language = {}
for file_name in translations_files:
manager.set_file_name(file_name)
file_data = manager.load_file()
try:
language_name = file_data['language_name']
dict_interface_language[language_name] = file_name
except:
pass
return dict_interface_language
if __name__ == "__main__":
main_folder = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
manager = UserConfigManager(main_folder)
folder_with_translations = YAMLFileManager(main_folder, "config.yaml").load_file()["folder_with_translations"]
data = manager.get_user_config(folder_with_translations)
print(data) | utils/user_config_manager.py | steklyashka33-Minecraft-Mod-Translator-92de64d | [
{
"filename": "utils/get_data.py",
"retrieved_chunk": " # get config\n config = YAMLFileManager(self.main_folder, \"config.yaml\").load_file()\n #get user_config\n folder_with_translations = config[\"folder_with_translations\"]\n user_config = UserConfigManager(self.main_folder).get_user_config(folder_with_translations)\n #get lang\n language_file = user_config[\"dict_interface_language\"][ user_config[\"interface_language\"] ]\n lang = YAMLFileManager(os.path.join( self.main_folder, folder_with_translations ), language_file).load_file()\n #get supported_languages\n supported_languages_file_name = \"supported_languages.yaml\"",
"score": 60.872290036779546
},
{
"filename": "utils/get_data.py",
"retrieved_chunk": "from .yaml_file_manager import YAMLFileManager\nfrom .user_config_manager import UserConfigManager\nfrom .dataclass import DataClass\nimport os\nclass GetData:\n \"\"\"work with data.\"\"\"\n def __init__(self, main_folder) -> None:\n self.main_folder = main_folder\n def get(self) -> tuple[DataClass, DataClass, DataClass, dict]:\n \"\"\"returns config, user_config, lang, supported_languages data.\"\"\"",
"score": 40.12673073633779
},
{
"filename": "APP.py",
"retrieved_chunk": " self.main_folder = os.path.dirname(os.path.abspath(__file__))\n self.data = GetData(self.main_folder)\n self.config, self.user_config, _, i = self.data.get()\n # get supported_languages\n # print(dict( [[a[\"google_code\"], a[\"mc_code\"]] for a in i.values()] ))\n # создание главного окна\n self.title( self.config.title ) # type: ignore\n window_width = 640\n window_height = 480\n set_appearance_mode(self.user_config.appearance_mode) # Modes: \"System\" (standard), \"Dark\", \"Light\" # type: ignore",
"score": 34.144011711598345
},
{
"filename": "ModTranslator/mod_translator/check_mods_translation.py",
"retrieved_chunk": " file_path = os.path.join(self._directory, file_name)\n if not os.path.isfile(file_path):\n comment = f\"no file found {file_name}.\"\n if self._exception_handler:\n self._exception_handler(comment)\n continue\n else:\n raise FileNotFoundError(comment)\n manager = PathToLanguages(file_path)\n if not manager.isFolderWithTranslations():",
"score": 33.81469885865113
},
{
"filename": "utils/get_data.py",
"retrieved_chunk": " supported_languages = YAMLFileManager(self.main_folder, supported_languages_file_name).load_file()\n config_class = DataClass(**config)\n user_config_class = DataClass(**user_config)\n lang_class = DataClass(**lang)\n return config_class, user_config_class, lang_class, supported_languages\n def get_main_folder(self):\n \"\"\"returns main_folder.\"\"\"\n return self.main_folder",
"score": 32.41444067511529
}
] | python | get_yaml_files() |
import logging
from pathlib import Path
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms as T
from torchvision.utils import save_image
from muse_maskgit_pytorch.vqvae import VQVAE
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# where to find the model and the test images
model_repo = "neggles/vaedump"
model_subdir = "vit-s-vqgan-f4"
test_images = ["testimg_1.png", "testimg_2.png"]
# where to save the preprocessed and reconstructed images
image_dir = Path.cwd().joinpath("temp")
image_dir.mkdir(exist_ok=True, parents=True)
# image transforms for the VQVAE
transform_enc = T.Compose([T.Resize(512), T.RandomCrop(256), T.ToTensor()])
transform_dec = T.Compose([T.ConvertImageDtype(torch.uint8), T.ToPILImage()])
def get_save_path(path: Path, append: str) -> Path:
# append a string to the filename before the extension
# n.b. only keeps the final suffix, e.g. "foo.xyz.png" -> "foo-prepro.png"
return path.with_name(f"{path.stem}-{append}{path.suffix}")
def main():
torch_device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
dtype = torch.float32
# load VAE
logger.info(f"Loading VQVAE from {model_repo}/{model_subdir}...")
vae: VQVAE = VQVAE. | from_pretrained(model_repo, subfolder=model_subdir, torch_dtype=dtype) |
vae = vae.to(torch_device)
logger.info(f"Loaded VQVAE from {model_repo} to {vae.device} with dtype {vae.dtype}")
# download and process images
for image in test_images:
image_path = hf_hub_download(model_repo, subfolder="images", filename=image, local_dir=image_dir)
image_path = Path(image_path)
logger.info(f"Downloaded {image_path}, size {image_path.stat().st_size} bytes")
# preprocess
image_obj = Image.open(image_path).convert("RGB")
image_tensor: torch.Tensor = transform_enc(image_obj)
save_path = get_save_path(image_path, "prepro")
save_image(image_tensor, save_path, normalize=True, range=(-1.0, 1.0))
logger.info(f"Saved preprocessed image to {save_path}")
# encode
encoded, _, _ = vae.encode(image_tensor.unsqueeze(0).to(vae.device))
# decode
reconstructed = vae.decode(encoded).squeeze(0)
reconstructed = torch.clamp(reconstructed, -1.0, 1.0)
# save
save_path = get_save_path(image_path, "recon")
save_image(reconstructed, save_path, normalize=True, range=(-1.0, 1.0))
logger.info(f"Saved reconstructed image to {save_path}")
# compare
image_prepro = transform_dec(image_tensor)
image_recon = transform_dec(reconstructed)
canvas = Image.new("RGB", (512 + 12, 256 + 8), (248, 248, 242))
canvas.paste(image_prepro, (4, 4))
canvas.paste(image_recon, (256 + 8, 4))
save_path = get_save_path(image_path, "compare")
canvas.save(save_path)
logger.info(f"Saved comparison image to {save_path}")
logger.info("Done!")
if __name__ == "__main__":
main()
| scripts/vqvae_test.py | Sygil-Dev-muse-maskgit-pytorch-7d7c00c | [
{
"filename": "infer_vae.py",
"retrieved_chunk": " else:\n accelerator.print(\"No checkpoints found in directory: \", args.vae_path)\n else:\n accelerator.print(\"Resuming VAE from: \", args.vae_path)\n vae.load(args.vae_path)\n if args.use_paintmind:\n # load VAE\n accelerator.print(\"Loading VQVAE from 'neggles/vaedump/vit-s-vqgan-f4' ...\")\n vae: VQVAE = VQVAE.from_pretrained(\"neggles/vaedump\", subfolder=\"vit-s-vqgan-f4\")\n elif args.taming_model_path:",
"score": 51.44936417433997
},
{
"filename": "muse_maskgit_pytorch/muse_maskgit_pytorch.py",
"retrieved_chunk": " def load(self, path):\n path = Path(path)\n if not path.exists() and path.is_file():\n raise ValueError(f\"cannot find file {path} (does not exist or is not a file)\")\n state_dict = torch.load(str(path), map_location=\"cpu\")\n self.load_state_dict(state_dict)\n def print(self, *args, **kwargs):\n return self.accelerator.print(*args, **kwargs) if self.accelerator else print(*args, **kwargs)\n @torch.no_grad()\n @eval_decorator",
"score": 38.31244036227653
},
{
"filename": "muse_maskgit_pytorch/attn/attn_test.py",
"retrieved_chunk": "import torch\nfrom torch import BoolTensor, FloatTensor, allclose, arange, manual_seed, no_grad, randn\nfrom torch.nn.functional import pad\nfrom muse_maskgit_pytorch.attn.ein_attn import Attention as EinAttn\nfrom muse_maskgit_pytorch.attn.xformers_attn import Attention as XformersAttn\ndevice = torch.device(\"cuda\")\ndtype = torch.float32\nseed = 42\n# realistically this would be 320 in stable-diffusion, but I'm going smaller during testing\nvision_dim = 64",
"score": 36.75953937297613
},
{
"filename": "infer_vae.py",
"retrieved_chunk": " # print (recon.shape) # torch.Size([1, 3, 512, 1136])\n save_image(recon, f\"{output_dir}/output.png\")\n else:\n # encode\n encoded, _, _ = vae.encode(\n dataset[i][None].to(accelerator.device if args.gpu == 0 else f\"cuda:{args.gpu}\")\n )\n # decode\n recon = vae.decode(encoded).squeeze(0)\n recon = torch.clamp(recon, -1.0, 1.0)",
"score": 36.512907537157496
},
{
"filename": "muse_maskgit_pytorch/muse_maskgit_pytorch.py",
"retrieved_chunk": " return torch.zeros(shape, device=device).float().uniform_(0, 1)\ndef prob_mask_like(shape, prob, device=None):\n if prob == 1:\n return torch.ones(shape, device=device, dtype=torch.bool)\n elif prob == 0:\n return torch.zeros(shape, device=device, dtype=torch.bool)\n else:\n return uniform(shape, device=device) < prob\n# sampling helpers\ndef log(t, eps=1e-20):",
"score": 36.01354652803926
}
] | python | from_pretrained(model_repo, subfolder=model_subdir, torch_dtype=dtype) |
from .yaml_file_manager import YAMLFileManager
from os.path import isfile, join
import os
class UserConfigManager():
"""manager for working with the user_config file."""
USER_CONFIG_TEMPLATE = {
'interface_language': 'English',
'dict_interface_language': None, #example: English: en.yaml
'appearance_mode': 'System', #number from the list system_list_of_appearance_modes
'last_path_to_mods': os.path.expanduser('~\\AppData\\Roaming\\.minecraft\\mods'),
'last_path_to_save': os.path.expanduser('~\\Documents\\translations'),
'startwith': '(Auto)',
}
FILE_NAME = "user_config.yaml"
def __init__(self, main_folder: str) -> None:
#checking for correct input
self._checking_the_path(main_folder)
self.main_folder = main_folder
@staticmethod
def _checking_the_path(folder) -> None:
"""checking the folder path for errors."""
if isinstance(folder, str):
if not os.path.isdir(folder):
raise NotADirectoryError(f"Directory '{folder}' does not exist.")
else:
raise TypeError("Directory must be a string.")
def get_user_config(self, folder_with_translations: str):
"""returns data from the user_config file."""
#checking for correct input
self._checking_the_path(os.path.join(self.main_folder, folder_with_translations))
file_manager = YAMLFileManager(self.main_folder, self.FILE_NAME)
if isfile( join(self.main_folder, self.FILE_NAME) ):
self.user_config = file_manager.load_file()
else:
self.user_config = self.USER_CONFIG_TEMPLATE
self.user_config['dict_interface_language'] = self._get_dictionary_of_interface_language(folder_with_translations)
return self.user_config
def save_user_config(self, data) -> None:
"""writes data to the user_config file."""
file_manager = YAMLFileManager(self.main_folder, self.FILE_NAME)
file_manager. | write_to_file(data) |
def _get_dictionary_of_interface_language(self, folder_with_translations):
"""return dict_interface_language."""
path_to_folder_with_translations = os.path.join(self.main_folder, folder_with_translations)
manager = YAMLFileManager(path_to_folder_with_translations)
translations_files = manager.get_yaml_files()
dict_interface_language = {}
for file_name in translations_files:
manager.set_file_name(file_name)
file_data = manager.load_file()
try:
language_name = file_data['language_name']
dict_interface_language[language_name] = file_name
except:
pass
return dict_interface_language
if __name__ == "__main__":
main_folder = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
manager = UserConfigManager(main_folder)
folder_with_translations = YAMLFileManager(main_folder, "config.yaml").load_file()["folder_with_translations"]
data = manager.get_user_config(folder_with_translations)
print(data) | utils/user_config_manager.py | steklyashka33-Minecraft-Mod-Translator-92de64d | [
{
"filename": "utils/get_data.py",
"retrieved_chunk": " # get config\n config = YAMLFileManager(self.main_folder, \"config.yaml\").load_file()\n #get user_config\n folder_with_translations = config[\"folder_with_translations\"]\n user_config = UserConfigManager(self.main_folder).get_user_config(folder_with_translations)\n #get lang\n language_file = user_config[\"dict_interface_language\"][ user_config[\"interface_language\"] ]\n lang = YAMLFileManager(os.path.join( self.main_folder, folder_with_translations ), language_file).load_file()\n #get supported_languages\n supported_languages_file_name = \"supported_languages.yaml\"",
"score": 65.27346232972363
},
{
"filename": "APP.py",
"retrieved_chunk": " if self.user_config.interface_language == language: # type: ignore\n return None\n self.user_config.interface_language = language # type: ignore\n UserConfigManager(self.main_folder).save_user_config(vars(self.user_config))\n session = self.main_frame.get_session_data()\n self.sidebar_frame.destroy()\n self.main_frame.destroy()\n self.build_sidebar()\n self.build_main(session)\n def update_appearance_mode(self, new_appearance_mode: str):",
"score": 49.53486873927748
},
{
"filename": "APP.py",
"retrieved_chunk": " if new_appearance_mode == self.user_config.appearance_mode: # type: ignore\n return \n self.user_config.appearance_mode = new_appearance_mode # type: ignore\n UserConfigManager(self.main_folder).save_user_config(vars(self.user_config))\n set_appearance_mode(new_appearance_mode)\n def run(self):\n # функция для запуска приложения\n self.mainloop()\nif __name__ == \"__main__\":\n app = App()",
"score": 48.49147018776377
},
{
"filename": "pages/page1.py",
"retrieved_chunk": " session = self.get_session_data()\n self.user_config.last_path_to_mods = session.path_to_mods # type: ignore\n self.user_config.last_path_to_save = session.path_to_save # type: ignore\n self.user_config.startwith = session.startwith # type: ignore\n UserConfigManager(self.main_folder).save_user_config(vars(self.user_config))\n if self._command:\n self._command(session)\n def checking_the_path(self, folder):\n try:\n UserConfigManager._checking_the_path(folder)",
"score": 48.16270505364652
},
{
"filename": "utils/get_data.py",
"retrieved_chunk": "from .yaml_file_manager import YAMLFileManager\nfrom .user_config_manager import UserConfigManager\nfrom .dataclass import DataClass\nimport os\nclass GetData:\n \"\"\"work with data.\"\"\"\n def __init__(self, main_folder) -> None:\n self.main_folder = main_folder\n def get(self) -> tuple[DataClass, DataClass, DataClass, dict]:\n \"\"\"returns config, user_config, lang, supported_languages data.\"\"\"",
"score": 47.16391089159196
}
] | python | write_to_file(data) |
import logging
import torch
import torch.nn as nn
from diffusers import ConfigMixin, ModelMixin
from diffusers.configuration_utils import register_to_config
from .layers import Decoder, Encoder
from .quantize import VectorQuantize
logger = logging.getLogger(__name__)
class VQVAE(ModelMixin, ConfigMixin):
@register_to_config
def __init__(self, n_embed, embed_dim, beta, enc, dec, **kwargs):
super().__init__()
self.encoder = Encoder(**enc)
self.decoder = Decoder(**dec)
self.prev_quant = nn.Linear(enc["dim"], embed_dim)
self.quantize = VectorQuantize(n_embed, embed_dim, beta)
self.post_quant = nn.Linear(embed_dim, dec["dim"])
def freeze(self):
self.eval()
self.requires_grad_(False)
def encode(self, x):
x = self.encoder(x)
x = self.prev_quant(x)
x, loss, indices = self.quantize(x)
return x, loss, indices
def decode(self, x):
x = self.post_quant(x)
x = self.decoder(x)
return x.clamp(-1.0, 1.0)
def forward(self, inputs: torch.FloatTensor):
z, loss, _ = self.encode(inputs)
rec = self.decode(z)
return rec, loss
def encode_to_ids(self, inputs):
_, _, indices = self.encode(inputs)
return indices
def decode_from_ids(self, indice):
z_q = self.quantize. | decode_ids(indice) |
img = self.decode(z_q)
return img
def __call__(self, inputs: torch.FloatTensor):
return self.forward(inputs)
| muse_maskgit_pytorch/vqvae/vqvae.py | Sygil-Dev-muse-maskgit-pytorch-7d7c00c | [
{
"filename": "muse_maskgit_pytorch/vqvae/quantize.py",
"retrieved_chunk": " )\n encoding_indices = torch.argmin(d, dim=1).view(*z.shape[:-1])\n z_q = self.embedding(encoding_indices).view(z.shape)\n z_q = F.normalize(z_q, p=2, dim=-1)\n # compute loss for embedding\n loss = self.beta * torch.mean((z_q.detach() - z) ** 2) + torch.mean((z_q - z.detach()) ** 2)\n # preserve gradients\n z_q = z + (z_q - z).detach()\n return z_q, loss, encoding_indices\n def decode_ids(self, indices):",
"score": 60.76377556210523
},
{
"filename": "muse_maskgit_pytorch/vqgan_vae_taming.py",
"retrieved_chunk": " img = self.model.decode(z)\n img = (img.clamp(-1.0, 1.0) + 1) * 0.5\n return img\n def encode(self, im_seq):\n # encode output\n # fmap, loss, (perplexity, min_encodings, min_encodings_indices) = self.model.encode(im_seq)\n fmap, loss, (_, _, min_encodings_indices) = self.model.encode(im_seq)\n b, _, h, w = fmap.shape\n min_encodings_indices = rearrange(min_encodings_indices, \"(b h w) -> b h w\", h=h, w=w, b=b)\n return fmap, min_encodings_indices, loss",
"score": 54.621176887021676
},
{
"filename": "muse_maskgit_pytorch/vqgan_vae_taming.py",
"retrieved_chunk": " @torch.no_grad()\n def get_codebook_indices(self, img):\n b = img.shape[0]\n img = (2 * img) - 1\n _, _, [_, _, indices] = self.model.encode(img)\n if self.is_gumbel:\n return rearrange(indices, \"b h w -> b (h w)\", b=b)\n return rearrange(indices, \"(b n) -> b n\", b=b)\n def get_encoded_fmap_size(self, image_size):\n return image_size // (2**self.num_layers)",
"score": 50.44190810471317
},
{
"filename": "muse_maskgit_pytorch/vqgan_vae.py",
"retrieved_chunk": " return torch_grad(\n outputs=loss,\n inputs=layer,\n grad_outputs=torch.ones_like(loss),\n retain_graph=True,\n )[0].detach()\n# vqgan vae\nclass LayerNormChan(nn.Module):\n def __init__(self, dim, eps=1e-5):\n super().__init__()",
"score": 45.718362936432044
},
{
"filename": "muse_maskgit_pytorch/vqgan_vae.py",
"retrieved_chunk": " def encode(self, fmap):\n fmap = self.enc_dec.encode(fmap)\n fmap, indices, commit_loss = self.vq(fmap)\n return fmap, indices, commit_loss\n def decode_from_ids(self, ids):\n codes = self.codebook[ids]\n fmap = self.vq.project_out(codes)\n fmap = rearrange(fmap, \"b h w c -> b c h w\")\n return self.decode(fmap)\n def decode(self, fmap):",
"score": 44.49375913027627
}
] | python | decode_ids(indice) |
import torch as ch
from tokenizer_wrappers.common import BaseTokenizer, update_input_data
from constants import WRONG_ORDS
class TransformerTokenizer(BaseTokenizer):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
"""
Encode methods
"""
def _tokenize(self, batch_of_sentences, max_length):
enc = self.tok(list(batch_of_sentences), max_length=max_length, padding=True, truncation=True, return_tensors="pt")
enc["input_tokens"] = list(list(self.tok.convert_ids_to_tokens(list(tok_sen))) for tok_sen in enc["input_ids"])
# This can only create 0 as token_type_id
enc["token_type_ids"] = ch.zeros_like(enc["attention_mask"])
return enc
def _update_tokenized(self, data_dict, max_length):
batch_of_sentences = self.decode_from_words(data_dict["input_words"], data_dict["word_mask"])
enc = self._tokenize(batch_of_sentences, max_length)
updated_data = update_input_data(enc, seq_len=max_length, pad_token=self.pad_token, pad_id=self.tok.pad_token_id)
return {"input_tokens": updated_data["input_tokens"], "input_ids": updated_data["input_ids"], "token_type_ids": updated_data["token_type_ids"], "attention_mask": updated_data["attention_mask"]}
def tokenize_from_sentences(self, batch_of_sentences, max_length):
enc = self._tokenize(batch_of_sentences, max_length)
word_ranges = self.get_word_ranges(enc["input_tokens"])
words, word_mask, token_word_mask = self. | extract_words(enc["input_tokens"], word_ranges) |
sentences = self.decode_from_words(words, word_mask)
# Retokenize to make sure decoding and encoding leads to same data
num_tries = 0
while num_tries < 3:
enc = self._tokenize(self.decode_from_words(words, word_mask), max_length)
word_ranges = self.get_word_ranges(enc["input_tokens"])
words, word_mask, token_word_mask = self.extract_words(enc["input_tokens"], word_ranges)
sentences_new = self.decode_from_words(words, word_mask)
if sentences_new == sentences:
break
else:
num_tries += 1
data_dict = {"sentences": self.decode_from_words(words, word_mask), "word_ranges": word_ranges, "input_words": words, "word_mask": word_mask, "token_mask": token_word_mask}
data_dict["tokenized"] = self._update_tokenized(data_dict, max_length)
return data_dict
"""
Decode methods
"""
def decode_from_tokenized(self, tokenized_dict: dict, remove_special_tokens=True, remove_pad_token=True) -> list:
to_remove = set()
if remove_pad_token:
to_remove.add(self.pad_token)
if remove_special_tokens:
to_remove.update(self.special_tokens)
sents = list(self.tok.batch_decode([[t for t in self.tok.convert_tokens_to_ids(
[w for w in sent if w not in to_remove])] for sent in tokenized_dict["input_tokens"]], skip_special_tokens=False, clean_up_tokenization_spaces=True))
sents = ["".join([c for c in s if ord(c) not in WRONG_ORDS]) for s in sents]
return sents
| tokenizer_wrappers/transformer_tokenizer.py | IBM-domain-adaptive-attribution-robustness-b4c2bee | [
{
"filename": "tokenizer_wrappers/clinicallongformer.py",
"retrieved_chunk": " def tokenize(self, batch_of_sentences, max_length, device=None):\n return_val = super().tokenize(batch_of_sentences, max_length, device)\n return_val[\"tokenized\"][\"global_attention_mask\"] = ch.zeros_like(return_val[\"tokenized\"][\"attention_mask\"])\n return_val[\"tokenized\"][\"global_attention_mask\"][:, 0] = 1\n return return_val\n def _tokenize(self, batch_of_sentences, max_length):\n enc = super()._tokenize(batch_of_sentences, max_length)\n enc[\"global_attention_mask\"] = ch.zeros_like(enc[\"attention_mask\"])\n enc[\"global_attention_mask\"][:, 0] = 1\n return enc",
"score": 134.4155909123598
},
{
"filename": "tokenizer_wrappers/clinicallongformer.py",
"retrieved_chunk": " def _update_tokenized(self, data_dict, max_length):\n enc = super()._update_tokenized(data_dict, max_length)\n enc[\"global_attention_mask\"] = ch.zeros_like(enc[\"attention_mask\"])\n enc[\"global_attention_mask\"][:, 0] = 1\n return enc",
"score": 116.72015899210247
},
{
"filename": "tokenizer_wrappers/common.py",
"retrieved_chunk": "import torch as ch\nclass BaseTokenizer(object):\n def __call__(self, *args, **kwargs):\n return self.tokenize(*args, **kwargs)\n def tokenize(self, batch_of_sentences, max_length, device=None):\n return_val = self.tokenize_from_sentences(batch_of_sentences, max_length)\n # Move tensors to specific device\n if device is not None:\n return_val[\"tokenized\"][\"input_ids\"] = return_val[\"tokenized\"][\"input_ids\"].to(device)\n return_val[\"tokenized\"][\"token_type_ids\"] = return_val[\"tokenized\"][\"token_type_ids\"].to(device)",
"score": 82.7945429996403
},
{
"filename": "tokenizer_wrappers/common.py",
"retrieved_chunk": " with ch.no_grad():\n for _i in range(len(data_dict[\"input_tokens\"])):\n data_dict[\"input_tokens\"][_i] = data_dict[\"input_tokens\"][_i] + (seq_len - len(data_dict[\"input_tokens\"][_i])) * [pad_token]\n helper_in_ids = ch.zeros(size=(data_dict[\"input_ids\"].size(0), seq_len), dtype=data_dict[\"input_ids\"].dtype, device=data_dict[\"input_ids\"].device)\n # Add the ID of pad token\n helper_in_ids += pad_id\n # Fill data with actual IDs\n for _i, _m in enumerate(data_dict[\"input_ids\"].unbind()):\n helper_in_ids[_i, :len(_m)] = _m\n data_dict[\"input_ids\"] = helper_in_ids",
"score": 75.03966915299122
},
{
"filename": "tokenizer_wrappers/common.py",
"retrieved_chunk": " return_val[\"tokenized\"][\"attention_mask\"] = return_val[\"tokenized\"][\"attention_mask\"].to(device)\n return return_val\n def tokenize_from_words(self, input_words, word_mask, max_length, device=None):\n return self.tokenize(self.decode_from_words(input_words, word_mask), max_length, device=device)\n def get_word_ranges(self, batch_tokenized_sentences: list) -> list:\n word_ranges = [[] for _ in batch_tokenized_sentences]\n # \"\"\"\n # No subword tokenization\n # \"\"\"\n if self.subtoken_prefix is None and self.token_space_prefix is None:",
"score": 66.62857484752962
}
] | python | extract_words(enc["input_tokens"], word_ranges) |
import torch as ch
from tokenizer_wrappers.common import BaseTokenizer, update_input_data
from constants import WRONG_ORDS
class TransformerTokenizer(BaseTokenizer):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
"""
Encode methods
"""
def _tokenize(self, batch_of_sentences, max_length):
enc = self.tok(list(batch_of_sentences), max_length=max_length, padding=True, truncation=True, return_tensors="pt")
enc["input_tokens"] = list(list(self.tok.convert_ids_to_tokens(list(tok_sen))) for tok_sen in enc["input_ids"])
# This can only create 0 as token_type_id
enc["token_type_ids"] = ch.zeros_like(enc["attention_mask"])
return enc
def _update_tokenized(self, data_dict, max_length):
batch_of_sentences = self. | decode_from_words(data_dict["input_words"], data_dict["word_mask"]) |
enc = self._tokenize(batch_of_sentences, max_length)
updated_data = update_input_data(enc, seq_len=max_length, pad_token=self.pad_token, pad_id=self.tok.pad_token_id)
return {"input_tokens": updated_data["input_tokens"], "input_ids": updated_data["input_ids"], "token_type_ids": updated_data["token_type_ids"], "attention_mask": updated_data["attention_mask"]}
def tokenize_from_sentences(self, batch_of_sentences, max_length):
enc = self._tokenize(batch_of_sentences, max_length)
word_ranges = self.get_word_ranges(enc["input_tokens"])
words, word_mask, token_word_mask = self.extract_words(enc["input_tokens"], word_ranges)
sentences = self.decode_from_words(words, word_mask)
# Retokenize to make sure decoding and encoding leads to same data
num_tries = 0
while num_tries < 3:
enc = self._tokenize(self.decode_from_words(words, word_mask), max_length)
word_ranges = self.get_word_ranges(enc["input_tokens"])
words, word_mask, token_word_mask = self.extract_words(enc["input_tokens"], word_ranges)
sentences_new = self.decode_from_words(words, word_mask)
if sentences_new == sentences:
break
else:
num_tries += 1
data_dict = {"sentences": self.decode_from_words(words, word_mask), "word_ranges": word_ranges, "input_words": words, "word_mask": word_mask, "token_mask": token_word_mask}
data_dict["tokenized"] = self._update_tokenized(data_dict, max_length)
return data_dict
"""
Decode methods
"""
def decode_from_tokenized(self, tokenized_dict: dict, remove_special_tokens=True, remove_pad_token=True) -> list:
to_remove = set()
if remove_pad_token:
to_remove.add(self.pad_token)
if remove_special_tokens:
to_remove.update(self.special_tokens)
sents = list(self.tok.batch_decode([[t for t in self.tok.convert_tokens_to_ids(
[w for w in sent if w not in to_remove])] for sent in tokenized_dict["input_tokens"]], skip_special_tokens=False, clean_up_tokenization_spaces=True))
sents = ["".join([c for c in s if ord(c) not in WRONG_ORDS]) for s in sents]
return sents
| tokenizer_wrappers/transformer_tokenizer.py | IBM-domain-adaptive-attribution-robustness-b4c2bee | [
{
"filename": "tokenizer_wrappers/clinicallongformer.py",
"retrieved_chunk": " def tokenize(self, batch_of_sentences, max_length, device=None):\n return_val = super().tokenize(batch_of_sentences, max_length, device)\n return_val[\"tokenized\"][\"global_attention_mask\"] = ch.zeros_like(return_val[\"tokenized\"][\"attention_mask\"])\n return_val[\"tokenized\"][\"global_attention_mask\"][:, 0] = 1\n return return_val\n def _tokenize(self, batch_of_sentences, max_length):\n enc = super()._tokenize(batch_of_sentences, max_length)\n enc[\"global_attention_mask\"] = ch.zeros_like(enc[\"attention_mask\"])\n enc[\"global_attention_mask\"][:, 0] = 1\n return enc",
"score": 117.50531310645323
},
{
"filename": "tokenizer_wrappers/clinicallongformer.py",
"retrieved_chunk": " def _update_tokenized(self, data_dict, max_length):\n enc = super()._update_tokenized(data_dict, max_length)\n enc[\"global_attention_mask\"] = ch.zeros_like(enc[\"attention_mask\"])\n enc[\"global_attention_mask\"][:, 0] = 1\n return enc",
"score": 117.03129891867556
},
{
"filename": "tokenizer_wrappers/common.py",
"retrieved_chunk": " return_val[\"tokenized\"][\"attention_mask\"] = return_val[\"tokenized\"][\"attention_mask\"].to(device)\n return return_val\n def tokenize_from_words(self, input_words, word_mask, max_length, device=None):\n return self.tokenize(self.decode_from_words(input_words, word_mask), max_length, device=device)\n def get_word_ranges(self, batch_tokenized_sentences: list) -> list:\n word_ranges = [[] for _ in batch_tokenized_sentences]\n # \"\"\"\n # No subword tokenization\n # \"\"\"\n if self.subtoken_prefix is None and self.token_space_prefix is None:",
"score": 55.78569587023864
},
{
"filename": "sentence_encoders/med_bce.py",
"retrieved_chunk": " self.chunk_size = 128 # MedSTS has a mean word count of ~48, therefore 128 seems a good chunk size\n self.name_tag = os.path.join(get_project_rootdir(), \"sentence_encoders\", \"models\",\n \"2019n2c2_tack1_roberta_stsc_6b_16b_3c_8c\")\n self.tokenizer = RobertaTokenizer.from_pretrained(self.name_tag)\n self.model = RobertaForSequenceClassification.from_pretrained(self.name_tag)\n def semantic_sim(self, sentence1, sentence2, reduction=\"min\", **kwargs):\n transformers.logging.set_verbosity_error()\n sent1_tok = self.tokenizer([sentence1], max_length=self.max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n sent2_tok = self.tokenizer([sentence2], max_length=self.max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n sentences1 = [self.tokenizer.decode(sent1_tok[\"input_ids\"][0][self.chunk_size*_i: self.chunk_size*(_i+1)], skip_special_tokens=True, clean_up_tokenization_spaces=True) for _i in range(int((self.max_length + self.chunk_size - 1)/self.chunk_size))]",
"score": 54.65686731107866
},
{
"filename": "tokenizer_wrappers/common.py",
"retrieved_chunk": "import torch as ch\nclass BaseTokenizer(object):\n def __call__(self, *args, **kwargs):\n return self.tokenize(*args, **kwargs)\n def tokenize(self, batch_of_sentences, max_length, device=None):\n return_val = self.tokenize_from_sentences(batch_of_sentences, max_length)\n # Move tensors to specific device\n if device is not None:\n return_val[\"tokenized\"][\"input_ids\"] = return_val[\"tokenized\"][\"input_ids\"].to(device)\n return_val[\"tokenized\"][\"token_type_ids\"] = return_val[\"tokenized\"][\"token_type_ids\"].to(device)",
"score": 54.08286290632463
}
] | python | decode_from_words(data_dict["input_words"], data_dict["word_mask"]) |
import os
import pandas as pd
from utils import get_dirname
from constants import CONCATENATOR, SEPARATOR
def construct_raw_data():
data_dir = None # Fill in path to raw data containing NOTEEVENTS, DIAGNOSES_ICD and PROCEDURES_ICD
out_dir = get_dirname(__file__)
load_args = {"header": 0, "compression": "gzip", "dtype": str, "on_bad_lines": "error"}
# Load event data
data = pd.read_csv(os.path.join(data_dir, "NOTEEVENTS.csv.gz"), **load_args)
data.columns = [col.lower() for col in data.columns]
# Filter out discharge summaries
data = data[data["category"] == "Discharge summary"]
# Load ICD9 diagnosis codes
icd9_d_data = pd.read_csv(os.path.join(data_dir, "DIAGNOSES_ICD.csv.gz"), **load_args)
icd9_d_data.columns = [col.lower() for col in icd9_d_data.columns]
# Load ICD9 procedure codes
icd9_p_data = pd.read_csv(os.path.join(data_dir, "PROCEDURES_ICD.csv.gz"), **load_args)
icd9_p_data.columns = [col.lower() for col in icd9_p_data.columns]
icd_code_dict = {}
icd9_codes = pd.concat([icd9_d_data, icd9_p_data], ignore_index=True)
for (subject_id, hadm_id), icd_df in icd9_codes.groupby(["subject_id", "hadm_id"]):
codes = CONCATENATOR. | join(sorted(icd_df["icd9_code"].astype(str).unique())) |
icd_code_dict[CONCATENATOR.join([subject_id, hadm_id])] = codes
data["icd9_code"] = data.apply(lambda row: icd_code_dict.get(CONCATENATOR.join([row["subject_id"], row["hadm_id"]]), ""), axis=1)
# Filter out empty ICD codes
data = data[data["icd9_code"] != ""]
data = data[data["icd9_code"] != "nan"]
data["text"] = data["text"].apply(lambda text: text.replace("\n", "\t"))
data["text"] = data["text"].apply(lambda text: text.replace(SEPARATOR, "<|>"))
data.to_csv(os.path.join(out_dir, f"mimic.csv"), sep=SEPARATOR, index_label="idx", na_rep="nan")
if __name__ == "__main__":
construct_raw_data() | data/raw/mimic/create_raw_data.py | IBM-domain-adaptive-attribution-robustness-b4c2bee | [
{
"filename": "data/datamodules.py",
"retrieved_chunk": " \"icd9_code\"].split(CONCATENATOR) if c in self.class2idx]), num_classes=len(self.class2idx)).sum(0), row[\"hadm_id\"]) for _, row in df.iterrows())\n def setup(self, stage: str = None):\n data = pd.concat([\n pd.read_csv(os.path.join(self.data_dir, filename), on_bad_lines=\"error\", **self.load_args) for filename in self.filenames], ignore_index=True)\n data = self.filter_data(data, self.filters)\n data = data.reset_index(drop=True)\n full_ds = self.extract_dataset_from_df(data)\n del data\n if self.load_big_train:\n with open(os.path.join(self.data_dir, \"test_50_hadm_ids.csv\")) as tef:",
"score": 92.72830790343467
},
{
"filename": "data/base_datamodule.py",
"retrieved_chunk": " (\"text\", \"ρ\"), (\"text\", \"ن\"), (\"text\", \"спa\"), (\"text\", \"л\"), (\"text\", \"н\"), (\"text\", \"я\"), (\"text\", \"б\"),\n (\"text\", \"п\"))\n def __init__(self, batch_size, seed: int = 0, train_ratio: float = 0.6, val_ratio: float = 0.2):\n super().__init__()\n self.batch_size = batch_size\n self.train_ratio = train_ratio\n self.val_ratio = val_ratio\n self.seed = seed\n def setup(self, stage: str = None):\n data = pd.concat([pd.read_csv(os.path.join(self.data_dir, filename), on_bad_lines=\"error\", **self.load_args) for filename in self.filenames], ignore_index=True)",
"score": 62.94638910515737
},
{
"filename": "data/datamodules.py",
"retrieved_chunk": " if not self.load_big_train:\n with open(os.path.join(self.data_dir, \"train_50_hadm_ids.csv\")) as trf, open(os.path.join(\n self.data_dir, \"test_50_hadm_ids.csv\")) as tef, open(os.path.join(self.data_dir, \"dev_50_hadm_ids.csv\")) as vf:\n indices = {l.replace(\"\\n\", \"\") for _file in [trf, tef, vf] for l in _file.readlines()}\n df = df[df[\"hadm_id\"].isin(indices)].reset_index(drop=True)\n if not self.load_big_train:\n return tuple((row[\"text\"], ch.nn.functional.one_hot(ch.tensor([self.class2idx[c] for c in row[\n \"icd9_code\"].split(CONCATENATOR) if c in self.class2idx]), num_classes=len(self.class2idx)).sum(0)) for _, row in df.iterrows())\n else:\n return tuple((row[\"text\"], ch.nn.functional.one_hot(ch.tensor([self.class2idx[c] for c in row[",
"score": 58.37639132118785
},
{
"filename": "data/datamodules.py",
"retrieved_chunk": " name = \"mimic\"\n multilabel = True\n data_dir = os.path.join(get_dirname(__file__), \"raw\", \"mimic\") # Run the Python script provided in that folder\n filenames = (\"mimic.csv\",)\n load_args = {\"header\": 0, \"dtype\": str, \"sep\": SEPARATOR}\n load_big_train = True\n class2idx = {'4019': 0, '3893': 1, '4280': 2, '42731': 3, '41401': 4, '9604': 5, '966': 6, '5849': 7, '25000': 8, '9671': 9,\n '2724': 10, '51881': 11, '9904': 12, '3961': 13, '5990': 14, '9672': 15, '53081': 16, '2720': 17, '311': 18,\n '2859': 19, '8856': 20, '486': 21, '2449': 22, '3615': 23, '3891': 24, '9915': 25, '2851': 26, '496': 27,\n '2762': 28, '5070': 29, '99592': 30, 'V5861': 31, '0389': 32, '8872': 33, '5859': 34, '40390': 35, '3722': 36,",
"score": 33.05164538232082
},
{
"filename": "data/datamodules.py",
"retrieved_chunk": " test_indices = {l.replace(\"\\n\", \"\") for l in tef.readlines() if l.replace(\"\\n\", \"\") != \"\"}\n tmp_test_ds = tuple((s[0], s[1]) for s in full_ds if s[2] in test_indices)\n with open(os.path.join(self.data_dir, \"dev_50_hadm_ids.csv\")) as tef:\n dev_indices = {l.replace(\"\\n\", \"\") for l in tef.readlines() if l.replace(\"\\n\", \"\") != \"\"}\n tmp_val_ds = tuple((s[0], s[1]) for s in full_ds if s[2] in dev_indices)\n tmp_train_ds = tuple((s[0], s[1]) for s in full_ds if s[2] not in dev_indices.union(test_indices))\n else:\n num_train = math.ceil(len(full_ds) * self.train_ratio)\n num_val = math.ceil(len(full_ds) * self.val_ratio)\n num_test = len(full_ds) - num_train - num_val",
"score": 28.792589084111974
}
] | python | join(sorted(icd_df["icd9_code"].astype(str).unique())) |
#
# ___ _ ____ ____
# / _ \ _ _ ___ ___| |_| _ \| __ )
# | | | | | | |/ _ \/ __| __| | | | _ \
# | |_| | |_| | __/\__ \ |_| |_| | |_) |
# \__\_\\__,_|\___||___/\__|____/|____/
#
# Copyright (c) 2014-2019 Appsicle
# Copyright (c) 2019-2023 QuestDB
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from examples import hello_world, psycopg2_connect, server_utilisation, sqlalchemy_orm, sqlalchemy_raw
def test_hello_world():
hello_world.main()
def test_psycopg2_connect():
psycopg2_connect.main()
def test_server_utilisation():
server_utilisation. | main(duration_sec=2.0) |
def test_sqlalchemy_orm():
sqlalchemy_orm.main()
def test_sqlalchemy_raw():
sqlalchemy_raw.main()
| tests/test_examples.py | questdb-questdb-connect-459ecb6 | [
{
"filename": "src/examples/sqlalchemy_raw.py",
"retrieved_chunk": "# limitations under the License.\n#\nimport sqlalchemy as sqla\ndef main():\n print(f\"SqlAlchemy {sqla.__version__}\")\n table_name = \"sqlalchemy_raw\"\n engine = sqla.create_engine(\"questdb://localhost:8812/main\", echo=True, future=True)\n try:\n with engine.connect() as conn:\n conn.execute(sqla.text(f\"DROP TABLE IF EXISTS {table_name}\"))",
"score": 25.277694128696986
},
{
"filename": "src/examples/server_utilisation.py",
"retrieved_chunk": " source = Column(qdbc.Symbol) # Nodes\n attr_name = Column(qdbc.Symbol) # Metrics\n attr_value = Column(qdbc.Double)\n ts = Column(qdbc.Timestamp, primary_key=True)\ndef main(duration_sec: float = 10.0):\n end_time = time.time() + max(duration_sec - 0.5, 2.0)\n engine = create_engine(\"questdb://localhost:8812/main\")\n session = Session(engine)\n max_batch_size = 3000\n try:",
"score": 23.104179241022138
},
{
"filename": "src/questdb_connect/identifier_preparer.py",
"retrieved_chunk": "# limitations under the License.\n#\nimport abc\nimport sqlalchemy\nfrom .common import quote_identifier\ndef _none(_ignore):\n return None\n_special_chars = {\n \"(\",\n \")\",",
"score": 18.603852110203952
},
{
"filename": "src/questdb_connect/inspector.py",
"retrieved_chunk": "# limitations under the License.\n#\nimport abc\nimport sqlalchemy\nfrom .common import PartitionBy\nfrom .table_engine import QDBTableEngine\nfrom .types import resolve_type_from_name\nclass QDBInspector(sqlalchemy.engine.reflection.Inspector, abc.ABC):\n def reflecttable(\n self,",
"score": 17.558363938055436
},
{
"filename": "tests/test_superset.py",
"retrieved_chunk": "# limitations under the License.\n#\nimport datetime\nfrom unittest import mock\nimport pytest\nfrom qdb_superset.db_engine_specs.questdb import QuestDbEngineSpec\nfrom questdb_connect.types import QUESTDB_TYPES, Timestamp\nfrom sqlalchemy import column, literal_column\nfrom sqlalchemy.types import TypeEngine\ndef test_build_sqlalchemy_uri():",
"score": 17.523873990482407
}
] | python | main(duration_sec=2.0) |
"""Mock socket streaming and listener that decodes on the fly"""
# Standard
from multiprocessing import Process
import random
import socket
import time
# Installed
import bitstring
import pytest
# Local
from space_packet_parser.xtcedef import XtcePacketDefinition
from space_packet_parser.parser import PacketParser
def send_data(sender: socket.socket, file: str):
"""Send data from a file as bytes via a socket with random chunk sizes and random waits between sending chunks
Parameters
----------
sender : socket.socket
Socket over which to send the data.
file : str
File to send as bytes over a socket connection
"""
# Read binary file
with open(file, 'rb') as fh:
stream = bitstring.ConstBitStream(fh)
while stream.pos < len(stream):
time.sleep(random.random() * .1) # Random sleep up to 1s
# Send binary data to socket in random chunk sizes
min_n_bytes = 4096
max_n_bytes = 4096*2
random_n_bytes = int(random.random()) * (max_n_bytes - min_n_bytes)
n_bits_to_send = 8 * (min_n_bytes + random_n_bytes)
if stream.pos + n_bits_to_send > len(stream):
n_bits_to_send = len(stream) - stream.pos
chunk_to_send = stream[stream.pos:stream.pos + n_bits_to_send]
sender.send(chunk_to_send.bytes)
stream.pos += n_bits_to_send
print("\nFinished sending data.")
def test_parsing_from_socket(jpss_test_data_dir):
# Create packet def
xdef = XtcePacketDefinition(jpss_test_data_dir / 'jpss1_geolocation_xtce_v1.xml')
# Create packet parser
parser = PacketParser(packet_definition=xdef)
# Create socket
sender, receiver = socket.socketpair()
receiver.settimeout(3)
file = jpss_test_data_dir / 'J01_G011_LZ_2021-04-09T00-00-00Z_V01.DAT1'
p = Process(target=send_data, args=(sender, file,))
p.start()
packet_generator = parser. | generator(receiver, buffer_read_size_bytes=4096, show_progress=True) |
with pytest.raises(socket.timeout):
packets = []
for p in packet_generator:
packets.append(p)
assert len(packets) == 7200
| tests/integration/test_socket_parsing.py | medley56-space_packet_parser-d94290c | [
{
"filename": "examples/parsing_and_plotting_idex_waveforms_from_socket.py",
"retrieved_chunk": " assert isinstance(idex_definition, xtcedef.XtcePacketDefinition)\n idex_parser = parser.PacketParser(idex_definition)\n idex_packet_file = idex_test_data_dir / 'sciData_2023_052_14_45_05'\n sender, receiver = socket.socketpair()\n receiver.settimeout(3)\n file = '/Users/game1390/Workspace/space/space_packet_parser/tests/test_data/jpss/J01_G011_LZ_2021-04-09T00-00-00Z_V01.DAT1'\n p = Process(target=send_data, args=(sender, idex_packet_file,))\n p.start()\n # Create a packet generator that listens to a socket\n idex_packet_generator = idex_parser.generator(receiver)",
"score": 143.8578665430513
},
{
"filename": "tests/integration/test_bufferedreader_parsing.py",
"retrieved_chunk": " assert isinstance(jpss_definition, xtcedef.XtcePacketDefinition)\n jpss_parser = parser.PacketParser(jpss_definition)\n jpss_packet_file = jpss_test_data_dir / 'J01_G011_LZ_2021-04-09T00-00-00Z_V01.DAT1'\n with jpss_packet_file.open('rb') as binary_data:\n jpss_packet_generator = jpss_parser.generator(binary_data, show_progress=True)\n n_packets = 0\n for jpss_packet in jpss_packet_generator:\n assert isinstance(jpss_packet, parser.Packet)\n assert jpss_packet.header['PKT_APID'].raw_value == 11\n assert jpss_packet.header['VERSION'].raw_value == 0",
"score": 49.549534819006304
},
{
"filename": "examples/parsing_and_plotting_idex_waveforms_from_socket.py",
"retrieved_chunk": "from space_packet_parser import parser\ndef send_data(sender: socket.socket, file: Path):\n \"\"\"Send data from a file as bytes via a socket with random chunk sizes and random waits between sending chunks\n Parameters\n ----------\n sender : socket.socket\n Socket over which to send the data.\n file : Path\n File to send as bytes over a socket connection\n \"\"\"",
"score": 47.350818073419426
},
{
"filename": "tests/integration/test_xtce_based_parsing/test_jpss_parsing.py",
"retrieved_chunk": " jpss_packet_file = jpss_test_data_dir / 'J01_G011_LZ_2021-04-09T00-00-00Z_V01.DAT1'\n with jpss_packet_file.open('rb') as binary_data:\n jpss_packet_generator = jpss_parser.generator(binary_data, show_progress=True)\n n_packets = 0\n for jpss_packet in jpss_packet_generator:\n assert isinstance(jpss_packet, parser.Packet)\n assert jpss_packet.header['PKT_APID'].raw_value == 11\n assert jpss_packet.header['VERSION'].raw_value == 0\n n_packets += 1\n assert n_packets == 7200",
"score": 44.83562654886629
},
{
"filename": "tests/integration/test_xtce_based_parsing/test_inheritance_restrictions.py",
"retrieved_chunk": " assert isinstance(jpss_definition, xtcedef.XtcePacketDefinition)\n jpss_parser = parser.PacketParser(jpss_definition)\n jpss_packet_file = jpss_test_data_dir / 'J01_G011_LZ_2021-04-09T00-00-00Z_V01.DAT1'\n with jpss_packet_file.open('rb') as binary_data:\n jpss_packet_generator = jpss_parser.generator(binary_data)\n for _ in range(3): # Iterate through 3 packets and check that the parsed APID remains the same\n jpss_packet = next(jpss_packet_generator)\n assert isinstance(jpss_packet, parser.Packet)\n assert jpss_packet.header['PKT_APID'].raw_value == 11\n assert jpss_packet.header['VERSION'].raw_value == 0",
"score": 42.18468505511347
}
] | python | generator(receiver, buffer_read_size_bytes=4096, show_progress=True) |
"""Integration tests on SUDA data
The packet definition used here is intended for IDEX, which is basically a rebuild of the SUDA instrument.
The data used here is SUDA data but the fields are parsed using IDEX naming conventions.
"""
# Installed
import bitstring
# Local
from space_packet_parser import xtcedef
from space_packet_parser import parser
def parse_hg_waveform(waveform_raw: str):
"""Parse a binary string representing a high gain waveform"""
w = bitstring.ConstBitStream(bin=waveform_raw)
ints = []
while w.pos < len(w):
w.read('bits:2') # skip 2. We use bits instead of pad for bitstring 3.0.0 compatibility
ints += w.readlist(['uint:10']*3)
return ints
def parse_lg_waveform(waveform_raw: str):
"""Parse a binary string representing a low gain waveform"""
w = bitstring.ConstBitStream(bin=waveform_raw)
ints = []
while w.pos < len(w):
w.read('bits:8') # skip 2
ints += w.readlist(['uint:12']*2)
return ints
def parse_waveform_data(waveform: str, scitype: int):
"""Parse the binary string that represents a waveform"""
print(f'Parsing waveform for scitype={scitype}')
if scitype in (2, 4, 8):
return parse_hg_waveform(waveform)
else:
return parse_lg_waveform(waveform)
def test_suda_xtce_packet_parsing(suda_test_data_dir):
"""Test parsing a real XTCE document"""
suda_xtce = suda_test_data_dir / 'suda_combined_science_definition.xml'
suda_definition = xtcedef. | XtcePacketDefinition(xtce_document=suda_xtce) |
assert isinstance(suda_definition, xtcedef.XtcePacketDefinition)
suda_parser = parser.PacketParser(suda_definition)
suda_packet_file = suda_test_data_dir / 'sciData_2022_130_17_41_53.spl'
with suda_packet_file.open('rb') as suda_binary_data:
suda_packet_generator = suda_parser.generator(suda_binary_data,
skip_header_bits=32,
show_progress=True)
for suda_packet in suda_packet_generator:
assert isinstance(suda_packet, parser.Packet)
assert suda_packet.header['PKT_APID'].raw_value == 1425, "APID is not as expected."
assert suda_packet.header['VERSION'].raw_value == 0, "CCSDS header VERSION incorrect."
suda_binary_data.pos = 0
suda_packet_generator = suda_parser.generator(suda_binary_data,
skip_header_bits=32)
try:
p = next(suda_packet_generator)
while True:
if 'IDX__SCIFETCHTYPE' in p.data:
scitype = p.data['IDX__SCIFETCHTYPE'].raw_value
print(scitype)
if scitype == 1: # beginning of an event
data = {}
event_header = p
# Each time we encounter a new scitype, we create a new array.
p = next(suda_packet_generator)
scitype = p.data['IDX__SCIFETCHTYPE'].raw_value
print(scitype, end=", ")
data[scitype] = p.data['IDX__SCIFETCHRAW'].raw_value
while True:
# If we run into the end of the file, this will raise StopIteration
p_next = next(suda_packet_generator)
next_scitype = p_next.data['IDX__SCIFETCHTYPE'].raw_value
print(next_scitype, end=", ")
if next_scitype == scitype:
# If the scitype is the same as the last packet, then concatenate them
data[scitype] += p_next.data['IDX__SCIFETCHRAW'].raw_value
else:
# Otherwise check if we are at the end of the event (next scitype==1)
if next_scitype == 1:
break
scitype = next_scitype
data[scitype] = p_next.data['IDX__SCIFETCHRAW'].raw_value
p = p_next
# If you have more than one event in a file (i.e. scitype 1, 2, 4, 8, 16, 32, 64),
# this loop would continue.
# For this example, we only have one full event so we have already hit a StopIteration by
# this point.
except StopIteration:
print("\nEncountered the end of the binary file.")
pass
expectations = {
2: {'len': 8193, 'mean': 511.8518247284267},
4: {'len': 8193, 'mean': 510.84450140363725},
8: {'len': 8193, 'mean': 510.99353106310264},
16: {'len': 512, 'mean': 2514.470703125},
32: {'len': 512, 'mean': 1989.7421875},
64: {'len': 512, 'mean': 2078.119140625}
}
# Parse the waveforms according to the scitype present (HG/LG channels encode waveform data differently)
for scitype, waveform in data.items():
data[scitype] = parse_waveform_data(waveform, scitype)
print(f"{len(data[scitype])} points")
mean = sum(data[scitype]) / len(data[scitype])
print(f"mean value = {mean}")
assert len(data[scitype]) == expectations[scitype]['len'], "Length of parsed waveform data does not match."
assert mean == expectations[scitype]['mean'], "Mean value does not match expectation"
assert set(data.keys()) == {2, 4, 8, 16, 32, 64}, "Missing a scitype value."
| tests/integration/test_xtce_based_parsing/test_suda_parsing.py | medley56-space_packet_parser-d94290c | [
{
"filename": "examples/parsing_and_plotting_idex_waveforms_from_socket.py",
"retrieved_chunk": " return ints\ndef parse_waveform_data(waveform: str, scitype: int):\n \"\"\"Parse the binary string that represents a waveform\"\"\"\n print(f'Parsing waveform for scitype={scitype}')\n if scitype in (2, 4, 8):\n return parse_hg_waveform(waveform)\n else:\n return parse_lg_waveform(waveform)\ndef plot_full_event(data: dict):\n \"\"\"Plot a full event (6 channels)\"\"\"",
"score": 86.68587169276117
},
{
"filename": "examples/parsing_and_plotting_idex_waveforms_from_socket.py",
"retrieved_chunk": " data = {scitype: parse_waveform_data(waveform, scitype) for scitype, waveform in data.items()}\n plot_full_event(data)\n print(\"\\nEncountered the end of the binary file.\")\n pass",
"score": 53.22753012286025
},
{
"filename": "examples/parsing_and_plotting_idex_waveforms_from_socket.py",
"retrieved_chunk": " p = p_next\n # If you have more than one complete event in a file (i.e. scitype 1, 2, 4, 8, 16, 32, 64),\n # this loop would continue.\n # For this example, we only have one full event so we have already hit a StopIteration by\n # this point.\n # We denote channels by their scitype value (2, 4, 8, 16, 32, 64) and parse the waveform binary blob\n # data using functions defined above.\n data = {scitype: parse_waveform_data(waveform, scitype) for scitype, waveform in data.items()}\n plot_full_event(data)\n except StopIteration:",
"score": 49.20074772296927
},
{
"filename": "tests/integration/test_bufferedreader_parsing.py",
"retrieved_chunk": "\"\"\"Integration test for parsing JPSS packets\"\"\"\n# Installed\nimport bitstring\n# Local\nfrom space_packet_parser import xtcedef\nfrom space_packet_parser import parser\ndef test_jpss_xtce_packet_parsing(jpss_test_data_dir):\n \"\"\"Test parsing a real XTCE document\"\"\"\n jpss_xtce = jpss_test_data_dir / 'jpss1_geolocation_xtce_v1.xml'\n jpss_definition = xtcedef.XtcePacketDefinition(xtce_document=jpss_xtce)",
"score": 34.6342299930997
},
{
"filename": "tests/integration/test_xtce_based_parsing/test_jpss_parsing.py",
"retrieved_chunk": "\"\"\"Integration test for parsing JPSS packets\"\"\"\n# Local\nfrom space_packet_parser import xtcedef\nfrom space_packet_parser import parser\ndef test_jpss_xtce_packet_parsing(jpss_test_data_dir):\n \"\"\"Test parsing a real XTCE document\"\"\"\n jpss_xtce = jpss_test_data_dir / 'jpss1_geolocation_xtce_v1.xml'\n jpss_definition = xtcedef.XtcePacketDefinition(xtce_document=jpss_xtce)\n assert isinstance(jpss_definition, xtcedef.XtcePacketDefinition)\n jpss_parser = parser.PacketParser(jpss_definition)",
"score": 34.324564449402416
}
] | python | XtcePacketDefinition(xtce_document=suda_xtce) |
"""Integration tests on SUDA data
The packet definition used here is intended for IDEX, which is basically a rebuild of the SUDA instrument.
The data used here is SUDA data but the fields are parsed using IDEX naming conventions.
"""
# Installed
import bitstring
# Local
from space_packet_parser import xtcedef
from space_packet_parser import parser
def parse_hg_waveform(waveform_raw: str):
"""Parse a binary string representing a high gain waveform"""
w = bitstring.ConstBitStream(bin=waveform_raw)
ints = []
while w.pos < len(w):
w.read('bits:2') # skip 2. We use bits instead of pad for bitstring 3.0.0 compatibility
ints += w.readlist(['uint:10']*3)
return ints
def parse_lg_waveform(waveform_raw: str):
"""Parse a binary string representing a low gain waveform"""
w = bitstring.ConstBitStream(bin=waveform_raw)
ints = []
while w.pos < len(w):
w.read('bits:8') # skip 2
ints += w.readlist(['uint:12']*2)
return ints
def parse_waveform_data(waveform: str, scitype: int):
"""Parse the binary string that represents a waveform"""
print(f'Parsing waveform for scitype={scitype}')
if scitype in (2, 4, 8):
return parse_hg_waveform(waveform)
else:
return parse_lg_waveform(waveform)
def test_suda_xtce_packet_parsing(suda_test_data_dir):
"""Test parsing a real XTCE document"""
suda_xtce = suda_test_data_dir / 'suda_combined_science_definition.xml'
suda_definition = xtcedef.XtcePacketDefinition(xtce_document=suda_xtce)
assert isinstance(suda_definition, xtcedef.XtcePacketDefinition)
suda_parser = parser. | PacketParser(suda_definition) |
suda_packet_file = suda_test_data_dir / 'sciData_2022_130_17_41_53.spl'
with suda_packet_file.open('rb') as suda_binary_data:
suda_packet_generator = suda_parser.generator(suda_binary_data,
skip_header_bits=32,
show_progress=True)
for suda_packet in suda_packet_generator:
assert isinstance(suda_packet, parser.Packet)
assert suda_packet.header['PKT_APID'].raw_value == 1425, "APID is not as expected."
assert suda_packet.header['VERSION'].raw_value == 0, "CCSDS header VERSION incorrect."
suda_binary_data.pos = 0
suda_packet_generator = suda_parser.generator(suda_binary_data,
skip_header_bits=32)
try:
p = next(suda_packet_generator)
while True:
if 'IDX__SCIFETCHTYPE' in p.data:
scitype = p.data['IDX__SCIFETCHTYPE'].raw_value
print(scitype)
if scitype == 1: # beginning of an event
data = {}
event_header = p
# Each time we encounter a new scitype, we create a new array.
p = next(suda_packet_generator)
scitype = p.data['IDX__SCIFETCHTYPE'].raw_value
print(scitype, end=", ")
data[scitype] = p.data['IDX__SCIFETCHRAW'].raw_value
while True:
# If we run into the end of the file, this will raise StopIteration
p_next = next(suda_packet_generator)
next_scitype = p_next.data['IDX__SCIFETCHTYPE'].raw_value
print(next_scitype, end=", ")
if next_scitype == scitype:
# If the scitype is the same as the last packet, then concatenate them
data[scitype] += p_next.data['IDX__SCIFETCHRAW'].raw_value
else:
# Otherwise check if we are at the end of the event (next scitype==1)
if next_scitype == 1:
break
scitype = next_scitype
data[scitype] = p_next.data['IDX__SCIFETCHRAW'].raw_value
p = p_next
# If you have more than one event in a file (i.e. scitype 1, 2, 4, 8, 16, 32, 64),
# this loop would continue.
# For this example, we only have one full event so we have already hit a StopIteration by
# this point.
except StopIteration:
print("\nEncountered the end of the binary file.")
pass
expectations = {
2: {'len': 8193, 'mean': 511.8518247284267},
4: {'len': 8193, 'mean': 510.84450140363725},
8: {'len': 8193, 'mean': 510.99353106310264},
16: {'len': 512, 'mean': 2514.470703125},
32: {'len': 512, 'mean': 1989.7421875},
64: {'len': 512, 'mean': 2078.119140625}
}
# Parse the waveforms according to the scitype present (HG/LG channels encode waveform data differently)
for scitype, waveform in data.items():
data[scitype] = parse_waveform_data(waveform, scitype)
print(f"{len(data[scitype])} points")
mean = sum(data[scitype]) / len(data[scitype])
print(f"mean value = {mean}")
assert len(data[scitype]) == expectations[scitype]['len'], "Length of parsed waveform data does not match."
assert mean == expectations[scitype]['mean'], "Mean value does not match expectation"
assert set(data.keys()) == {2, 4, 8, 16, 32, 64}, "Missing a scitype value."
| tests/integration/test_xtce_based_parsing/test_suda_parsing.py | medley56-space_packet_parser-d94290c | [
{
"filename": "tests/integration/test_xtce_based_parsing/test_jpss_parsing.py",
"retrieved_chunk": "\"\"\"Integration test for parsing JPSS packets\"\"\"\n# Local\nfrom space_packet_parser import xtcedef\nfrom space_packet_parser import parser\ndef test_jpss_xtce_packet_parsing(jpss_test_data_dir):\n \"\"\"Test parsing a real XTCE document\"\"\"\n jpss_xtce = jpss_test_data_dir / 'jpss1_geolocation_xtce_v1.xml'\n jpss_definition = xtcedef.XtcePacketDefinition(xtce_document=jpss_xtce)\n assert isinstance(jpss_definition, xtcedef.XtcePacketDefinition)\n jpss_parser = parser.PacketParser(jpss_definition)",
"score": 52.30584555217933
},
{
"filename": "tests/integration/test_bufferedreader_parsing.py",
"retrieved_chunk": "\"\"\"Integration test for parsing JPSS packets\"\"\"\n# Installed\nimport bitstring\n# Local\nfrom space_packet_parser import xtcedef\nfrom space_packet_parser import parser\ndef test_jpss_xtce_packet_parsing(jpss_test_data_dir):\n \"\"\"Test parsing a real XTCE document\"\"\"\n jpss_xtce = jpss_test_data_dir / 'jpss1_geolocation_xtce_v1.xml'\n jpss_definition = xtcedef.XtcePacketDefinition(xtce_document=jpss_xtce)",
"score": 41.62814729602679
},
{
"filename": "tests/integration/test_xtce_based_parsing/test_inheritance_restrictions.py",
"retrieved_chunk": "\"\"\"Test RestrictionCriteria being used creatively with JPSS data\"\"\"\n# Installed\nimport bitstring\n# Local\nfrom space_packet_parser import xtcedef\nfrom space_packet_parser import parser\ndef test_jpss_xtce_packet_parsing(jpss_test_data_dir):\n \"\"\"Test parsing a real XTCE document\"\"\"\n jpss_xtce = jpss_test_data_dir / 'contrived_inheritance_structure.xml'\n jpss_definition = xtcedef.XtcePacketDefinition(xtce_document=jpss_xtce)",
"score": 41.010380330286424
},
{
"filename": "examples/parsing_and_plotting_idex_waveforms_from_socket.py",
"retrieved_chunk": " return ints\ndef parse_waveform_data(waveform: str, scitype: int):\n \"\"\"Parse the binary string that represents a waveform\"\"\"\n print(f'Parsing waveform for scitype={scitype}')\n if scitype in (2, 4, 8):\n return parse_hg_waveform(waveform)\n else:\n return parse_lg_waveform(waveform)\ndef plot_full_event(data: dict):\n \"\"\"Plot a full event (6 channels)\"\"\"",
"score": 34.99956513574659
},
{
"filename": "tests/integration/test_bufferedreader_parsing.py",
"retrieved_chunk": " assert isinstance(jpss_definition, xtcedef.XtcePacketDefinition)\n jpss_parser = parser.PacketParser(jpss_definition)\n jpss_packet_file = jpss_test_data_dir / 'J01_G011_LZ_2021-04-09T00-00-00Z_V01.DAT1'\n with jpss_packet_file.open('rb') as binary_data:\n jpss_packet_generator = jpss_parser.generator(binary_data, show_progress=True)\n n_packets = 0\n for jpss_packet in jpss_packet_generator:\n assert isinstance(jpss_packet, parser.Packet)\n assert jpss_packet.header['PKT_APID'].raw_value == 11\n assert jpss_packet.header['VERSION'].raw_value == 0",
"score": 22.31712959137219
}
] | python | PacketParser(suda_definition) |
# third party
import os
from typing import List, Optional
from dbt.cli.main import dbtRunner
from dbt.contracts.graph.manifest import Manifest
from dbt.contracts.results import CatalogArtifact
from loguru import logger
class Dbt:
def __init__(self, manifest: Optional[Manifest] = None):
self.dbt_runner = dbtRunner(manifest=manifest) # type: ignore
def invoke(
self, directory: Optional[os.PathLike] = None, runner_args: Optional[List[str]] = None
):
starting_directory = os.getcwd()
if directory:
os.chdir(directory)
result = self.dbt_runner. | invoke(runner_args if runner_args else []) |
os.chdir(starting_directory)
if not result.success and result.exception:
raise result.exception
return result.result
def parse(self, directory: os.PathLike):
logger.info("Executing dbt parse...")
return self.invoke(directory, ["--quiet", "parse"])
def ls(
self,
directory: os.PathLike,
arguments: Optional[List[str]] = None,
output_key: Optional[str] = None,
) -> List[str]:
"""
Execute dbt ls with the given arguments and return the result as a list of strings.
Log level is set to none to prevent dbt from printing to stdout.
"""
args = ["--log-format", "json", "--log-level", "none", "ls"]
if arguments:
args.extend(arguments)
if output_key:
args.extend(["--output", "json", "--output-keys", output_key])
return self.invoke(directory, args)
def docs_generate(self, directory: os.PathLike) -> CatalogArtifact:
"""
Excute dbt docs generate with the given arguments
"""
logger.info("Generating catalog with dbt docs generate...")
args = ["--quiet", "docs", "generate"]
return self.invoke(directory, args)
| dbt_meshify/dbt.py | dbt-labs-dbt-meshify-a11e507 | [
{
"filename": "dbt_meshify/dbt_projects.py",
"retrieved_chunk": " )\n def __init__(\n self,\n manifest: Manifest,\n project: Project,\n catalog: CatalogArtifact,\n dbt: Dbt,\n path: Path = Path(os.getcwd()),\n name: Optional[str] = None,\n ) -> None:",
"score": 52.54595901142158
},
{
"filename": "dbt_meshify/dbt_projects.py",
"retrieved_chunk": " \"\"\"A base-level representation of a dbt project.\"\"\"\n def __init__(\n self,\n manifest: Manifest,\n project: Project,\n catalog: CatalogArtifact,\n name: Optional[str] = None,\n ) -> None:\n self.manifest = manifest\n self.project = project",
"score": 40.57236099833955
},
{
"filename": "dbt_meshify/main.py",
"retrieved_chunk": "@click.pass_context\ndef group(\n ctx,\n name,\n project_path: os.PathLike,\n group_yml_path: os.PathLike,\n select: str,\n read_catalog: bool,\n owner_name: Optional[str] = None,\n owner_email: Optional[str] = None,",
"score": 39.52505825967331
},
{
"filename": "tests/dbt_project_utils.py",
"retrieved_chunk": "import shutil\nfrom pathlib import Path\nfrom dbt_meshify.dbt import Dbt\ndbt = Dbt()\ndef setup_test_project(src_project_path, dest_project_path):\n src_path = Path(src_project_path)\n dest_path = Path(dest_project_path)\n shutil.copytree(src_path, dest_path)\n dbt.invoke(directory=dest_project_path, runner_args=[\"deps\"])\n dbt.invoke(directory=dest_project_path, runner_args=[\"seed\"])",
"score": 38.9908151025804
},
{
"filename": "tests/dbt_project_utils.py",
"retrieved_chunk": " dbt.invoke(directory=dest_project_path, runner_args=[\"run\"])\ndef teardown_test_project(dest_project_path):\n dest_path = Path(dest_project_path)\n shutil.rmtree(dest_path)",
"score": 38.47206453453452
}
] | python | invoke(runner_args if runner_args else []) |
import networkx
import pytest
from dbt.node_types import AccessType
from dbt_meshify.utilities.grouper import ResourceGrouper
class TestResourceGrouper:
@pytest.fixture
def example_graph(self):
graph = networkx.DiGraph()
graph.add_edges_from([("a", "b"), ("b", "c"), ("b", "d"), ("d", "1")])
return graph
@pytest.fixture
def example_graph_with_tests(self):
graph = networkx.DiGraph()
graph.add_edges_from(
[
("source.a", "model.b"),
("model.b", "test.c"),
("model.b", "model.d"),
("model.d", "test.1"),
]
)
return graph
def test_resource_grouper_boundary_classification(self, example_graph):
nodes = {"a", "b", "c", "d"}
resources = ResourceGrouper.classify_resource_access(example_graph, nodes)
assert resources == {
"a": AccessType.Private,
"b": AccessType.Private,
"c": AccessType.Public,
"d": AccessType.Public,
}
def test_clean_graph_removes_test_nodes(self, example_graph_with_tests):
output_graph = ResourceGrouper. | clean_subgraph(example_graph_with_tests) |
assert set(output_graph.nodes) == {"source.a", "model.b", "model.d"}
| tests/unit/test_resource_grouper_classification.py | dbt-labs-dbt-meshify-a11e507 | [
{
"filename": "dbt_meshify/utilities/grouper.py",
"retrieved_chunk": " whereas nodes that are not a referenced are safe for a private access level.\n \"\"\"\n boundary_nodes = cls.identify_interface(graph, nodes)\n resources = {\n node: AccessType.Public if node in boundary_nodes else AccessType.Private\n for node in nodes\n }\n logger.info(f\"Identified resource access types based on the graph: {resources}\")\n return resources\n @classmethod",
"score": 45.53259137394903
},
{
"filename": "tests/unit/test_add_group_and_access_to_model_yml.py",
"retrieved_chunk": " access_type=AccessType.Public,\n models_yml=read_yml(model_yml_shared_model_with_group),\n )\n assert yml_dict == read_yml(expected_model_yml_shared_model)\n def test_preserves_existing_models(self, new_group: Group):\n yml_dict = meshify.add_group_and_access_to_model_yml(\n model_name=model_name,\n group=new_group,\n access_type=AccessType.Public,\n models_yml=read_yml(model_yml_multiple_models),",
"score": 34.369636080830965
},
{
"filename": "tests/unit/test_add_group_and_access_to_model_yml.py",
"retrieved_chunk": " model_name=model_name,\n group=new_group,\n access_type=AccessType.Public,\n models_yml=read_yml(model_yml_shared_model),\n )\n assert yml_dict == read_yml(expected_model_yml_shared_model)\n def test_adds_group_overwrites_existing_groups(self, new_group: Group):\n yml_dict = meshify.add_group_and_access_to_model_yml(\n model_name=model_name,\n group=new_group,",
"score": 26.21690944680438
},
{
"filename": "dbt_meshify/utilities/grouper.py",
"retrieved_chunk": " cleaned_subgraph = self.clean_subgraph(self.project.graph.graph)\n resources = self.classify_resource_access(cleaned_subgraph, nodes)\n return group, resources\n def add_group(\n self,\n name: str,\n owner: Owner,\n path: os.PathLike,\n select: str,\n exclude: Optional[str] = None,",
"score": 22.173968762767032
},
{
"filename": "dbt_meshify/linker.py",
"retrieved_chunk": " downstream_mesh_constructor = DbtMeshConstructor(\n project_path=downstream_project.path,\n node=downstream_manifest_entry, # type: ignore\n catalog=None,\n )\n downstream_editor = DbtProjectEditor(downstream_project)\n # for either dependency type, add contracts and make model public\n try:\n upstream_mesh_constructor.add_model_access(AccessType.Public)\n logger.success(",
"score": 21.947452576684924
}
] | python | clean_subgraph(example_graph_with_tests) |
import os
import subprocess
from pathlib import Path
import yaml
from dbt_meshify.dbt import Dbt
from dbt_meshify.dbt_projects import DbtProject
from dbt_meshify.storage.dbt_project_editors import DbtSubprojectCreator
from dbt_meshify.storage.file_content_editors import DbtMeshConstructor
test_project_profile = yaml.safe_load(
"""
test:
outputs:
dev:
path: ./database.db
threads: 2
type: duckdb
target: dev
"""
)
test_package_yml = yaml.safe_load(
"""
packages:
- package: dbt-labs/dbt_utils
version: 1.0.0
"""
)
model_unique_id = "model.test.my_first_dbt_model"
def setup_new_project(write_packages_yml: bool = False):
dbt = Dbt()
subprocess.run(["poetry", "run", "dbt", "init", "test", "-s"])
with open("test/profiles.yml", "w") as f:
f.write(yaml.dump(test_project_profile))
if write_packages_yml:
with open("test/packages.yml", "w") as f:
f.write(yaml.dump(test_package_yml))
dbt. | invoke(directory=Path("test"), runner_args=["deps"]) |
def split_project(select: str = "my_first_dbt_model"):
project = DbtProject.from_directory(Path("test"), read_catalog=False)
subproject = project.split(project_name='subdir', select=select)
return subproject
def get_meshify_constructor(subproject, unique_id):
resource = subproject.get_manifest_node(unique_id)
if not resource:
raise KeyError(f"Resource {unique_id} not found in manifest")
meshify_constructor = DbtMeshConstructor(
project_path=subproject.path, node=resource, catalog=None
)
return meshify_constructor
def teardown_new_project():
os.system("rm -rf test-projects/test")
class TestDbtSubprojectCreator:
def test_move_model_file(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
original_contents = Path("test/models/example/my_first_dbt_model.sql").read_text()
subproject = split_project()
meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
creator = DbtSubprojectCreator(subproject)
creator.move_resource(meshify_constructor)
assert Path("test/subdir/models/example/my_first_dbt_model.sql").exists()
assert not Path("test/models/example/my_first_dbt_model.sql").exists()
assert (
Path("test/subdir/models/example/my_first_dbt_model.sql").read_text()
== original_contents
)
os.chdir(starting_directory)
teardown_new_project()
def test_copy_model_file(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
subproject = split_project()
meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
creator = DbtSubprojectCreator(subproject)
creator.copy_resource(meshify_constructor)
assert Path("test/subdir/models/example/my_first_dbt_model.sql").exists()
assert Path("test/models/example/my_first_dbt_model.sql").exists()
assert (
Path("test/subdir/models/example/my_first_dbt_model.sql").read_text()
== Path("test/models/example/my_first_dbt_model.sql").read_text()
)
os.chdir(starting_directory)
teardown_new_project()
def test_move_yml_entry(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
subproject = split_project()
meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
creator = DbtSubprojectCreator(subproject)
creator.update_resource_yml_entry(meshify_constructor)
# the original path should still exist, since we take only the single model entry
assert Path("test/models/example/schema.yml").exists()
assert Path("test/subdir/models/example/schema.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
def test_write_project_yml(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
subproject = split_project()
creator = DbtSubprojectCreator(subproject)
creator.write_project_file()
# the original path should still exist, since we take only the single model entry
assert Path("test/dbt_project.yml").exists()
assert Path("test/subdir/dbt_project.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
def test_write_packages_yml(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project(write_packages_yml=True)
subproject = split_project()
creator = DbtSubprojectCreator(subproject)
creator.copy_packages_yml_file()
# the original path should still exist, since we take only the single model entry
assert Path("test/packages.yml").exists()
assert Path("test/subdir/packages.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
def test_write_dependencies_yml(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project(write_packages_yml=True)
subproject = split_project()
creator = DbtSubprojectCreator(subproject)
creator.update_dependencies_yml()
# the original path should still exist, since we take only the single model entry
assert Path("test/dependencies.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
| tests/integration/test_subproject_creator.py | dbt-labs-dbt-meshify-a11e507 | [
{
"filename": "tests/integration/test_create_group_command.py",
"retrieved_chunk": " start_group_yml_content = yaml.safe_load(start_group_yml)\n with open(group_yml_file, \"w\") as f:\n yaml.safe_dump(start_group_yml_content, f, sort_keys=False)\n with open(other_model_file, \"w\") as f:\n f.write(\"select 1 as test\")\n runner = CliRunner()\n result = runner.invoke(\n create_group,\n [\n \"test_group\",",
"score": 68.75263731457477
},
{
"filename": "tests/integration/test_create_group_command.py",
"retrieved_chunk": " with open(model_yml_file, \"w\") as f:\n yaml.safe_dump(start_yml_content, f, sort_keys=False)\n start_group_yml_content = yaml.safe_load(start_group_yml)\n with open(group_yml_file, \"w\") as f:\n yaml.safe_dump(start_group_yml_content, f, sort_keys=False)\n runner = CliRunner()\n result = runner.invoke(\n create_group,\n [\n \"test_group\",",
"score": 54.63301879128599
},
{
"filename": "tests/integration/test_create_group_command.py",
"retrieved_chunk": "def test_group_group_owner_properties(name, email, end_group_yml):\n group_yml_file = proj_path / \"models\" / \"_groups.yml\"\n model_yml_file = proj_path / \"models\" / \"_models.yml\"\n group_yml_file.parent.mkdir(parents=True, exist_ok=True)\n model_yml_file.parent.mkdir(parents=True, exist_ok=True)\n start_yml_content = yaml.safe_load(model_yml_shared_model)\n with open(model_yml_file, \"w\") as f:\n yaml.safe_dump(start_yml_content, f, sort_keys=False)\n start_group_yml_content = yaml.safe_load(group_yml_empty_file)\n with open(group_yml_file, \"w\") as f:",
"score": 47.05621490642023
},
{
"filename": "tests/integration/test_contract_command.py",
"retrieved_chunk": " start_yml_content = yaml.safe_load(start_yml)\n with open(yml_file, \"w+\") as f:\n yaml.safe_dump(start_yml_content, f, sort_keys=False)\n args = [\"--select\", \"shared_model\", \"--project-path\", proj_path_string]\n if read_catalog:\n args.append(\"--read-catalog\")\n result = runner.invoke(add_contract, args)\n assert result.exit_code == 0\n # reset the read path to the default in the logic\n with open(yml_file, \"r\") as f:",
"score": 42.118336186757126
},
{
"filename": "tests/integration/test_version_command.py",
"retrieved_chunk": "def reset_model_files(files_list):\n models_dir = proj_path / \"models\"\n for file in models_dir.glob(\"*\"):\n if file.is_file():\n file.unlink()\n for file in files_list:\n file_path = proj_path / \"models\" / file\n if not file_path.is_file():\n with file_path.open(\"w+\") as f:\n f.write(shared_model_sql)",
"score": 38.208886414686056
}
] | python | invoke(directory=Path("test"), runner_args=["deps"]) |
from pathlib import Path
import pytest
from click.testing import CliRunner
from dbt_meshify.dbt_projects import DbtProject
from dbt_meshify.main import group
from tests.dbt_project_utils import setup_test_project, teardown_test_project
src_path_string = "test-projects/split/split_proj"
dest_path_string = "test-projects/split/temp_proj"
proj_path = Path(dest_path_string)
# this test should encapsulate the following:
# 1. group is created in the project with proper yml
# 2. public models also have contracts
# since we handle the creation and validation of yml in other tests, this shouldn't need many fixtures
@pytest.mark.parametrize(
"select,expected_public_contracted_models",
[
(
"+orders",
["orders"],
),
],
ids=["1"],
)
def test_group_command(select, expected_public_contracted_models):
setup_test_project(src_path_string, dest_path_string)
runner = CliRunner()
result = runner.invoke(
group,
[
"test_group",
"--owner-name",
"Teenage Mutant Jinja Turtles",
"--select",
select,
"--project-path",
dest_path_string,
],
)
assert result.exit_code == 0
project = DbtProject. | from_directory(proj_path, read_catalog=False) |
# ensure that the correct set of public models is created
public_contracted_models = [
model.name
for model_key, model in project.models.items()
if model.access == "public" and model.config.contract.enforced
]
assert public_contracted_models == expected_public_contracted_models
teardown_test_project(dest_path_string)
| tests/integration/test_group_command.py | dbt-labs-dbt-meshify-a11e507 | [
{
"filename": "tests/integration/test_split_command.py",
"retrieved_chunk": " \"my_new_project\",\n \"--project-path\",\n dest_project_path,\n \"--select\",\n \"+stg_order_items\",\n ],\n )\n assert result.exit_code == 0\n # moved model\n assert (",
"score": 24.735305149360347
},
{
"filename": "tests/integration/test_contract_command.py",
"retrieved_chunk": " )\n assert result.exit_code == 0\n result2 = runner.invoke(\n add_contract, [\"--select\", \"new_model\", \"--project-path\", proj_path_string]\n )\n assert result2.exit_code == 0\n # reset the read path to the default in the logic\n with open(yml_file, \"r\") as f:\n actual = yaml.safe_load(f)\n yml_file.unlink()",
"score": 20.15216360884968
},
{
"filename": "tests/integration/test_contract_command.py",
"retrieved_chunk": " start_yml_content = yaml.safe_load(start_yml)\n with open(yml_file, \"w+\") as f:\n yaml.safe_dump(start_yml_content, f, sort_keys=False)\n args = [\"--select\", \"shared_model\", \"--project-path\", proj_path_string]\n if read_catalog:\n args.append(\"--read-catalog\")\n result = runner.invoke(add_contract, args)\n assert result.exit_code == 0\n # reset the read path to the default in the logic\n with open(yml_file, \"r\") as f:",
"score": 20.08960892577519
},
{
"filename": "dbt_meshify/main.py",
"retrieved_chunk": "@selector\[email protected](\"--prerelease\", \"--pre\", default=False, is_flag=True)\[email protected](\"--defined-in\", default=None)\ndef add_version(select, exclude, project_path, selector, prerelease, defined_in, read_catalog):\n \"\"\"\n Adds/increments model versions for all selected models.\n \"\"\"\n path = Path(project_path).expanduser().resolve()\n logger.info(f\"Reading dbt project at {path}\")\n project = DbtProject.from_directory(path, read_catalog)",
"score": 19.392644761638135
},
{
"filename": "tests/integration/test_dependency_detection.py",
"retrieved_chunk": " return DbtProject.from_directory(\n Path(\"test-projects/source-hack/src_proj_a/\").resolve(), read_catalog=False\n )\n @pytest.fixture\n def src_proj_b(self) -> DbtProject:\n \"\"\"Load the `src_proj_b` project.\"\"\"\n return DbtProject.from_directory(\n Path(\"test-projects/source-hack/src_proj_b/\").resolve(), read_catalog=False\n )\n @pytest.fixture",
"score": 19.32360725106615
}
] | python | from_directory(proj_path, read_catalog=False) |
import os
import subprocess
from pathlib import Path
import yaml
from dbt_meshify.dbt import Dbt
from dbt_meshify.dbt_projects import DbtProject
from dbt_meshify.storage.dbt_project_editors import DbtSubprojectCreator
from dbt_meshify.storage.file_content_editors import DbtMeshConstructor
test_project_profile = yaml.safe_load(
"""
test:
outputs:
dev:
path: ./database.db
threads: 2
type: duckdb
target: dev
"""
)
test_package_yml = yaml.safe_load(
"""
packages:
- package: dbt-labs/dbt_utils
version: 1.0.0
"""
)
model_unique_id = "model.test.my_first_dbt_model"
def setup_new_project(write_packages_yml: bool = False):
dbt = Dbt()
subprocess.run(["poetry", "run", "dbt", "init", "test", "-s"])
with open("test/profiles.yml", "w") as f:
f.write(yaml.dump(test_project_profile))
if write_packages_yml:
with open("test/packages.yml", "w") as f:
f.write(yaml.dump(test_package_yml))
dbt.invoke(directory=Path("test"), runner_args=["deps"])
def split_project(select: str = "my_first_dbt_model"):
project = DbtProject.from_directory(Path("test"), read_catalog=False)
subproject = project.split(project_name='subdir', select=select)
return subproject
def get_meshify_constructor(subproject, unique_id):
resource = subproject.get_manifest_node(unique_id)
if not resource:
raise KeyError(f"Resource {unique_id} not found in manifest")
meshify_constructor = DbtMeshConstructor(
project_path=subproject.path, node=resource, catalog=None
)
return meshify_constructor
def teardown_new_project():
os.system("rm -rf test-projects/test")
class TestDbtSubprojectCreator:
def test_move_model_file(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
original_contents = Path("test/models/example/my_first_dbt_model.sql").read_text()
subproject = split_project()
meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
creator = DbtSubprojectCreator(subproject)
creator.move_resource(meshify_constructor)
assert Path("test/subdir/models/example/my_first_dbt_model.sql").exists()
assert not Path("test/models/example/my_first_dbt_model.sql").exists()
assert (
Path("test/subdir/models/example/my_first_dbt_model.sql").read_text()
== original_contents
)
os.chdir(starting_directory)
teardown_new_project()
def test_copy_model_file(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
subproject = split_project()
meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
creator = DbtSubprojectCreator(subproject)
creator.copy_resource(meshify_constructor)
assert Path("test/subdir/models/example/my_first_dbt_model.sql").exists()
assert Path("test/models/example/my_first_dbt_model.sql").exists()
assert (
Path("test/subdir/models/example/my_first_dbt_model.sql").read_text()
== Path("test/models/example/my_first_dbt_model.sql").read_text()
)
os.chdir(starting_directory)
teardown_new_project()
def test_move_yml_entry(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
subproject = split_project()
meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
creator = DbtSubprojectCreator(subproject)
creator.update_resource_yml_entry(meshify_constructor)
# the original path should still exist, since we take only the single model entry
assert Path("test/models/example/schema.yml").exists()
assert Path("test/subdir/models/example/schema.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
def test_write_project_yml(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
subproject = split_project()
creator = DbtSubprojectCreator(subproject)
creator.write_project_file()
# the original path should still exist, since we take only the single model entry
assert Path("test/dbt_project.yml").exists()
assert Path("test/subdir/dbt_project.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
def test_write_packages_yml(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project(write_packages_yml=True)
subproject = split_project()
creator = DbtSubprojectCreator(subproject)
creator.copy_packages_yml_file()
# the original path should still exist, since we take only the single model entry
assert Path("test/packages.yml").exists()
assert Path("test/subdir/packages.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
def test_write_dependencies_yml(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project(write_packages_yml=True)
subproject = split_project()
creator = DbtSubprojectCreator(subproject)
creator. | update_dependencies_yml() |
# the original path should still exist, since we take only the single model entry
assert Path("test/dependencies.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
| tests/integration/test_subproject_creator.py | dbt-labs-dbt-meshify-a11e507 | [
{
"filename": "dbt_meshify/dbt.py",
"retrieved_chunk": " def invoke(\n self, directory: Optional[os.PathLike] = None, runner_args: Optional[List[str]] = None\n ):\n starting_directory = os.getcwd()\n if directory:\n os.chdir(directory)\n result = self.dbt_runner.invoke(runner_args if runner_args else [])\n os.chdir(starting_directory)\n if not result.success and result.exception:\n raise result.exception",
"score": 52.3647015719486
},
{
"filename": "dbt_meshify/dbt_projects.py",
"retrieved_chunk": " )\n def __init__(\n self,\n manifest: Manifest,\n project: Project,\n catalog: CatalogArtifact,\n dbt: Dbt,\n path: Path = Path(os.getcwd()),\n name: Optional[str] = None,\n ) -> None:",
"score": 22.24742626860915
},
{
"filename": "dbt_meshify/main.py",
"retrieved_chunk": " if create_path:\n create_path = Path(create_path).expanduser().resolve()\n create_path.parent.mkdir(parents=True, exist_ok=True)\n subproject_creator = DbtSubprojectCreator(project=subproject, target_directory=create_path)\n logger.info(f\"Creating subproject {subproject.name}...\")\n try:\n subproject_creator.initialize()\n logger.success(f\"Successfully created subproject {subproject.name}\")\n except Exception as e:\n raise FatalMeshifyException(f\"Error creating subproject {subproject.name}: error {e}\")",
"score": 19.726206361885318
},
{
"filename": "dbt_meshify/main.py",
"retrieved_chunk": "@click.pass_context\ndef group(\n ctx,\n name,\n project_path: os.PathLike,\n group_yml_path: os.PathLike,\n select: str,\n read_catalog: bool,\n owner_name: Optional[str] = None,\n owner_email: Optional[str] = None,",
"score": 16.155339768101555
},
{
"filename": "dbt_meshify/main.py",
"retrieved_chunk": "@project_path\n@read_catalog\n@select\n@selector\ndef create_group(\n name,\n project_path: os.PathLike,\n group_yml_path: os.PathLike,\n select: str,\n read_catalog: bool,",
"score": 15.456320323537419
}
] | python | update_dependencies_yml() |
import os
import subprocess
from pathlib import Path
import yaml
from dbt_meshify.dbt import Dbt
from dbt_meshify.dbt_projects import DbtProject
from dbt_meshify.storage.dbt_project_editors import DbtSubprojectCreator
from dbt_meshify.storage.file_content_editors import DbtMeshConstructor
test_project_profile = yaml.safe_load(
"""
test:
outputs:
dev:
path: ./database.db
threads: 2
type: duckdb
target: dev
"""
)
test_package_yml = yaml.safe_load(
"""
packages:
- package: dbt-labs/dbt_utils
version: 1.0.0
"""
)
model_unique_id = "model.test.my_first_dbt_model"
def setup_new_project(write_packages_yml: bool = False):
dbt = Dbt()
subprocess.run(["poetry", "run", "dbt", "init", "test", "-s"])
with open("test/profiles.yml", "w") as f:
f.write(yaml.dump(test_project_profile))
if write_packages_yml:
with open("test/packages.yml", "w") as f:
f.write(yaml.dump(test_package_yml))
dbt.invoke(directory=Path("test"), runner_args=["deps"])
def split_project(select: str = "my_first_dbt_model"):
project = DbtProject. | from_directory(Path("test"), read_catalog=False) |
subproject = project.split(project_name='subdir', select=select)
return subproject
def get_meshify_constructor(subproject, unique_id):
resource = subproject.get_manifest_node(unique_id)
if not resource:
raise KeyError(f"Resource {unique_id} not found in manifest")
meshify_constructor = DbtMeshConstructor(
project_path=subproject.path, node=resource, catalog=None
)
return meshify_constructor
def teardown_new_project():
os.system("rm -rf test-projects/test")
class TestDbtSubprojectCreator:
def test_move_model_file(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
original_contents = Path("test/models/example/my_first_dbt_model.sql").read_text()
subproject = split_project()
meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
creator = DbtSubprojectCreator(subproject)
creator.move_resource(meshify_constructor)
assert Path("test/subdir/models/example/my_first_dbt_model.sql").exists()
assert not Path("test/models/example/my_first_dbt_model.sql").exists()
assert (
Path("test/subdir/models/example/my_first_dbt_model.sql").read_text()
== original_contents
)
os.chdir(starting_directory)
teardown_new_project()
def test_copy_model_file(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
subproject = split_project()
meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
creator = DbtSubprojectCreator(subproject)
creator.copy_resource(meshify_constructor)
assert Path("test/subdir/models/example/my_first_dbt_model.sql").exists()
assert Path("test/models/example/my_first_dbt_model.sql").exists()
assert (
Path("test/subdir/models/example/my_first_dbt_model.sql").read_text()
== Path("test/models/example/my_first_dbt_model.sql").read_text()
)
os.chdir(starting_directory)
teardown_new_project()
def test_move_yml_entry(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
subproject = split_project()
meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
creator = DbtSubprojectCreator(subproject)
creator.update_resource_yml_entry(meshify_constructor)
# the original path should still exist, since we take only the single model entry
assert Path("test/models/example/schema.yml").exists()
assert Path("test/subdir/models/example/schema.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
def test_write_project_yml(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project()
subproject = split_project()
creator = DbtSubprojectCreator(subproject)
creator.write_project_file()
# the original path should still exist, since we take only the single model entry
assert Path("test/dbt_project.yml").exists()
assert Path("test/subdir/dbt_project.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
def test_write_packages_yml(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project(write_packages_yml=True)
subproject = split_project()
creator = DbtSubprojectCreator(subproject)
creator.copy_packages_yml_file()
# the original path should still exist, since we take only the single model entry
assert Path("test/packages.yml").exists()
assert Path("test/subdir/packages.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
def test_write_dependencies_yml(self) -> None:
starting_directory = os.getcwd()
os.chdir(Path("test-projects"))
setup_new_project(write_packages_yml=True)
subproject = split_project()
creator = DbtSubprojectCreator(subproject)
creator.update_dependencies_yml()
# the original path should still exist, since we take only the single model entry
assert Path("test/dependencies.yml").exists()
os.chdir(starting_directory)
teardown_new_project()
| tests/integration/test_subproject_creator.py | dbt-labs-dbt-meshify-a11e507 | [
{
"filename": "tests/integration/test_create_group_command.py",
"retrieved_chunk": " start_group_yml_content = yaml.safe_load(start_group_yml)\n with open(group_yml_file, \"w\") as f:\n yaml.safe_dump(start_group_yml_content, f, sort_keys=False)\n with open(other_model_file, \"w\") as f:\n f.write(\"select 1 as test\")\n runner = CliRunner()\n result = runner.invoke(\n create_group,\n [\n \"test_group\",",
"score": 72.76462005131243
},
{
"filename": "tests/integration/test_create_group_command.py",
"retrieved_chunk": " with open(model_yml_file, \"w\") as f:\n yaml.safe_dump(start_yml_content, f, sort_keys=False)\n start_group_yml_content = yaml.safe_load(start_group_yml)\n with open(group_yml_file, \"w\") as f:\n yaml.safe_dump(start_group_yml_content, f, sort_keys=False)\n runner = CliRunner()\n result = runner.invoke(\n create_group,\n [\n \"test_group\",",
"score": 54.633018791285984
},
{
"filename": "tests/integration/test_create_group_command.py",
"retrieved_chunk": "def test_group_group_owner_properties(name, email, end_group_yml):\n group_yml_file = proj_path / \"models\" / \"_groups.yml\"\n model_yml_file = proj_path / \"models\" / \"_models.yml\"\n group_yml_file.parent.mkdir(parents=True, exist_ok=True)\n model_yml_file.parent.mkdir(parents=True, exist_ok=True)\n start_yml_content = yaml.safe_load(model_yml_shared_model)\n with open(model_yml_file, \"w\") as f:\n yaml.safe_dump(start_yml_content, f, sort_keys=False)\n start_group_yml_content = yaml.safe_load(group_yml_empty_file)\n with open(group_yml_file, \"w\") as f:",
"score": 47.05621490642023
},
{
"filename": "tests/integration/test_contract_command.py",
"retrieved_chunk": " start_yml_content = yaml.safe_load(start_yml)\n with open(yml_file, \"w+\") as f:\n yaml.safe_dump(start_yml_content, f, sort_keys=False)\n args = [\"--select\", \"shared_model\", \"--project-path\", proj_path_string]\n if read_catalog:\n args.append(\"--read-catalog\")\n result = runner.invoke(add_contract, args)\n assert result.exit_code == 0\n # reset the read path to the default in the logic\n with open(yml_file, \"r\") as f:",
"score": 46.74564457409799
},
{
"filename": "tests/integration/test_contract_command.py",
"retrieved_chunk": " # in situations where models don't have a patch path, there isn't a yml file to read from\n if start_yml:\n yml_file.touch()\n start_yml_content = yaml.safe_load(start_yml)\n with open(yml_file, \"w+\") as f:\n yaml.safe_dump(start_yml_content, f, sort_keys=False)\n result = runner.invoke(\n add_contract, [\"--select\", \"shared_model\", \"--project-path\", proj_path_string]\n )\n assert result.exit_code == 0",
"score": 39.50116226760649
}
] | python | from_directory(Path("test"), read_catalog=False) |
import networkx
import pytest
from dbt.node_types import AccessType
from dbt_meshify.utilities.grouper import ResourceGrouper
class TestResourceGrouper:
@pytest.fixture
def example_graph(self):
graph = networkx.DiGraph()
graph.add_edges_from([("a", "b"), ("b", "c"), ("b", "d"), ("d", "1")])
return graph
@pytest.fixture
def example_graph_with_tests(self):
graph = networkx.DiGraph()
graph.add_edges_from(
[
("source.a", "model.b"),
("model.b", "test.c"),
("model.b", "model.d"),
("model.d", "test.1"),
]
)
return graph
def test_resource_grouper_boundary_classification(self, example_graph):
nodes = {"a", "b", "c", "d"}
resources = ResourceGrouper. | classify_resource_access(example_graph, nodes) |
assert resources == {
"a": AccessType.Private,
"b": AccessType.Private,
"c": AccessType.Public,
"d": AccessType.Public,
}
def test_clean_graph_removes_test_nodes(self, example_graph_with_tests):
output_graph = ResourceGrouper.clean_subgraph(example_graph_with_tests)
assert set(output_graph.nodes) == {"source.a", "model.b", "model.d"}
| tests/unit/test_resource_grouper_classification.py | dbt-labs-dbt-meshify-a11e507 | [
{
"filename": "dbt_meshify/storage/dbt_project_editors.py",
"retrieved_chunk": " nodes = set(filter(lambda x: not x.startswith(\"source\"), self.project.resources)) # type: ignore\n parent_project_name = self.project.parent_project.name # type: ignore\n interface = ResourceGrouper.identify_interface(\n graph=self.project.graph.graph, selected_bunch=nodes\n )\n boundary_models = set(\n filter(\n lambda x: (x.startswith(\"model\") and x.split('.')[1] == parent_project_name),\n interface,\n )",
"score": 24.736955363782684
},
{
"filename": "dbt_meshify/utilities/grouper.py",
"retrieved_chunk": " cleaned_subgraph = self.clean_subgraph(self.project.graph.graph)\n resources = self.classify_resource_access(cleaned_subgraph, nodes)\n return group, resources\n def add_group(\n self,\n name: str,\n owner: Owner,\n path: os.PathLike,\n select: str,\n exclude: Optional[str] = None,",
"score": 22.365403048446307
},
{
"filename": "dbt_meshify/dbt_projects.py",
"retrieved_chunk": " \"model\",\n \"seed\",\n \"snapshot\",\n \"test\",\n \"analysis\",\n \"snapshot\",\n ]:\n return self.manifest.nodes.get(unique_id)\n pluralized = NodeType(unique_id.split(\".\")[0]).pluralize()\n resources = getattr(self.manifest, pluralized)",
"score": 21.569999044292217
},
{
"filename": "dbt_meshify/utilities/grouper.py",
"retrieved_chunk": " def clean_subgraph(cls, graph: networkx.DiGraph) -> networkx.DiGraph:\n \"\"\"Generate a subgraph that does not contain test resource types.\"\"\"\n test_nodes = set(node for node in graph.nodes if node.startswith('test'))\n return graph.subgraph(set(graph.nodes) - test_nodes)\n def _generate_resource_group(\n self,\n name: str,\n owner: Owner,\n path: os.PathLike,\n select: str,",
"score": 19.99235617542679
},
{
"filename": "dbt_meshify/dbt_projects.py",
"retrieved_chunk": " for model in self.models.values()\n if any(\n parent\n for parent in self.get_manifest_node(model.unique_id).depends_on.nodes\n if parent in self.resources\n )\n and model.unique_id not in self.resources\n }\n def _get_xproj_parents_of_selected_nodes(self) -> Set[str]:\n return {",
"score": 19.217893035687588
}
] | python | classify_resource_access(example_graph, nodes) |
import argparse
import json
import interpreter
from Evals import get_path, conEval, robEval, creEval
import matplotlib.pyplot as plt
class Evaluator :
def __init__(
self
):
self.data = {}
self.para = {}
self.label = ''
def read_data(self, indir) :
self.data = json.load(open(indir, encoding = 'utf-8'))
return self.data
def get_label(self, str) :
str = str.split('\\')[-1]
self.label = str[:str.find('.')]
def read_para(self, type = 'robustness', res_dir = None) :
indir = 'Datasets\Attacker_out\\'+type+'\\'+self.label+'.json'
self.para = json.load(open(indir, encoding = 'utf-8'))
if res_dir != None :
self.interpreter = interpreter.Interpreter()
self.para = self.interpreter.get_llm_answer(self.para, res_dir)
def get_answerpath(self) :
self.para = get_path. | get_path(self.para, self.data) |
def eval(self, type) :
print(self.label)
if type == 'robustness' :
plt.figure(figsize=(10, 6), dpi=80)
plt.suptitle(type+self.label, fontsize = 20)
error_rate, changed_rate, SUM = robEval.get_score(self.para)
print('ER score:', '\n', error_rate, '\n\n',
'ASR score:', changed_rate, '\n\n', 'sum: ', SUM)
robEval.draw_table(error_rate, changed_rate, SUM)
plt.tight_layout()
plt.show()
elif type == 'consistency' :
gt_result, changed_result, SUM = conEval.get_score(self.para)
print('Groundtruth:', '\n', gt_result, '\n\n',
'Attacked:', changed_result, '\n\n', 'sum: ', SUM)
elif type == 'credibility' :
plt.figure(figsize=(10, 6), dpi=80)
plt.suptitle(type+self.label, fontsize = 20)
Rate_list = creEval.get_rate(self.para).copy()
SUM = 0
for key in Rate_list :
Rate_list[key] = round(sum([i for i in Rate_list[key]])/len(Rate_list[key]), 3)
SUM += Rate_list[key]
print('RTI score in '+self.label+' : '+round(SUM/3, 3))+'\\\\'
plt.show()
def process(self, config) :
self.read_data(config['indir'])
self.get_label(config['indir'])
self.read_para(config['type'], config['res_dir'])
self.get_answerpath()
self.eval(config['type'])
def main() :
parser = argparse.ArgumentParser()
parser.add_argument(
"--indir",
type = str,
nargs = "?",
default = None,
help = "input directory"
)
parser.add_argument(
"--response_dir",
type = str,
nargs = "?",
default = None,
help = "response directory"
)
parser.add_argument(
"--type",
type = str,
nargs = "?",
default = "robustness",
help = "test type including robusteness, consistency and credibility"
)
opt = parser.parse_args()
config = {
'type' : opt.type,
'indir' : opt.indir,
'res_dir' : opt.response_dir
}
evaluator = Evaluator()
evaluator.process(config)
if __name__ == '__main__' :
main() | eval.py | ZJUM3-LLMEval_RCC-a731888 | [
{
"filename": "interpreter.py",
"retrieved_chunk": " i += 1\n total_time = end-start\n print(\"total time \", total_time)\n return self.para\n def get_llm_answer(self, para, res_dir) :\n res = json.load(open(res_dir, encoding = 'utf-8'))\n for id in para :\n self.para[id]['response'] = res[i]\n i += 1\n if 'new_passage' in para[id] :",
"score": 75.24519467888135
},
{
"filename": "processor.py",
"retrieved_chunk": " self.para = self.attacker.process(type = config['type'], dict = self.data, \n outdir = outdir, p_dir = config['p_dir'], \n iter = config['iter'], cred = config['cred'])\n print('Attacked form data is stored in \\''+outdir+'\\'')\n def question_interpreter(self, config, type = 'robustness') :\n self.interpreter = interpreter.Interpreter()\n if not config['use_chatgpt'] : outdir = 'Datasets\\Queation_out\\\\'+type+'\\\\'+self.label+'.json'\n else : outdir = 'Datasets\\Interpreter_out\\\\'+type+'\\\\'+self.label+'_question.json'\n para = self.interpreter.process(type = type, dict_para = self.para, dict_data = self.data,\n indir_prompt = config['p_dir'], api_key = config['api_key'],",
"score": 72.86121735287504
},
{
"filename": "interpreter.py",
"retrieved_chunk": " self.data = {}\n self.para = {}\n self.result = {}\n self.question = []\n def read_data(self, indir) :\n self.data = json.load(open(indir, encoding = 'utf-8'))\n return self.data\n def read_para(self, indir) :\n self.para = json.load(open(indir, encoding = 'utf-8'))\n return self.para",
"score": 67.31757445871465
},
{
"filename": "Analysor/analysis_pos_parser.py",
"retrieved_chunk": "class Para_analyse : \n def __init__(\n self\n ) :\n self.para = {}\n self.result = {}\n def read_para(self, indir) :\n self.para = json.load(open(indir, encoding = 'utf-8'))\n self.result['dataset'] = indir.split('\\\\')[-2]\n return self.para",
"score": 60.97149971608341
},
{
"filename": "processor.py",
"retrieved_chunk": "import argparse\nimport json\nimport converter, generator, attacker, interpreter\nclass Processor :\n def __init__(\n self\n ):\n self.data = {}\n self.para = {}\n self.label = ''",
"score": 58.39514796400314
}
] | python | get_path(self.para, self.data) |
import argparse
import json
import interpreter
from Evals import get_path, conEval, robEval, creEval
import matplotlib.pyplot as plt
class Evaluator :
def __init__(
self
):
self.data = {}
self.para = {}
self.label = ''
def read_data(self, indir) :
self.data = json.load(open(indir, encoding = 'utf-8'))
return self.data
def get_label(self, str) :
str = str.split('\\')[-1]
self.label = str[:str.find('.')]
def read_para(self, type = 'robustness', res_dir = None) :
indir = 'Datasets\Attacker_out\\'+type+'\\'+self.label+'.json'
self.para = json.load(open(indir, encoding = 'utf-8'))
if res_dir != None :
self.interpreter = interpreter.Interpreter()
self.para = self.interpreter.get_llm_answer(self.para, res_dir)
def get_answerpath(self) :
self.para = get_path.get_path(self.para, self.data)
def eval(self, type) :
print(self.label)
if type == 'robustness' :
plt.figure(figsize=(10, 6), dpi=80)
plt.suptitle(type+self.label, fontsize = 20)
error_rate, changed_rate, SUM = robEval.get_score(self.para)
print('ER score:', '\n', error_rate, '\n\n',
'ASR score:', changed_rate, '\n\n', 'sum: ', SUM)
robEval. | draw_table(error_rate, changed_rate, SUM) |
plt.tight_layout()
plt.show()
elif type == 'consistency' :
gt_result, changed_result, SUM = conEval.get_score(self.para)
print('Groundtruth:', '\n', gt_result, '\n\n',
'Attacked:', changed_result, '\n\n', 'sum: ', SUM)
elif type == 'credibility' :
plt.figure(figsize=(10, 6), dpi=80)
plt.suptitle(type+self.label, fontsize = 20)
Rate_list = creEval.get_rate(self.para).copy()
SUM = 0
for key in Rate_list :
Rate_list[key] = round(sum([i for i in Rate_list[key]])/len(Rate_list[key]), 3)
SUM += Rate_list[key]
print('RTI score in '+self.label+' : '+round(SUM/3, 3))+'\\\\'
plt.show()
def process(self, config) :
self.read_data(config['indir'])
self.get_label(config['indir'])
self.read_para(config['type'], config['res_dir'])
self.get_answerpath()
self.eval(config['type'])
def main() :
parser = argparse.ArgumentParser()
parser.add_argument(
"--indir",
type = str,
nargs = "?",
default = None,
help = "input directory"
)
parser.add_argument(
"--response_dir",
type = str,
nargs = "?",
default = None,
help = "response directory"
)
parser.add_argument(
"--type",
type = str,
nargs = "?",
default = "robustness",
help = "test type including robusteness, consistency and credibility"
)
opt = parser.parse_args()
config = {
'type' : opt.type,
'indir' : opt.indir,
'res_dir' : opt.response_dir
}
evaluator = Evaluator()
evaluator.process(config)
if __name__ == '__main__' :
main() | eval.py | ZJUM3-LLMEval_RCC-a731888 | [
{
"filename": "Evals/robEval.py",
"retrieved_chunk": "import matplotlib.pyplot as plt\nimport numpy as np\nimport math\ndef get_score(para) :\n rate_result, rate_sum, error_rate = {}, {}, {}\n changed_rate = {}\n error_rate['ori'], SUM = {0 : 0}, 0\n for id in para : \n SUM += len(para[id]['answer'])\n for _ in range(len(para[id]['answer'])) :",
"score": 65.59262393665277
},
{
"filename": "Evals/robEval.py",
"retrieved_chunk": " for attack_type in error_rate : \n try :\n error_rate[attack_type] = sum([error_rate[attack_type][key] for key in error_rate[attack_type].keys()])\n error_rate[attack_type] /= SUM if attack_type == 'ori' else sum([rate_sum[attack_type][key] for key in rate_sum[attack_type].keys()])\n error_rate[attack_type] = round(error_rate[attack_type]*100, 2)\n if attack_type == 'ori' : continue\n changed_rate[attack_type] = sum([rate_result[attack_type][key] for key in rate_result[attack_type].keys()])/sum([rate_sum[attack_type][key] for key in rate_sum[attack_type].keys()])\n changed_rate[attack_type] = round(changed_rate[attack_type]*100, 2)\n except: continue\n return error_rate, changed_rate, SUM",
"score": 63.64257598608943
},
{
"filename": "Analysor/analysis_pos_parser.py",
"retrieved_chunk": " plt.figure(figsize=(10, 8), dpi=80)\n plt.rcParams.update({'font.size': 20})\n # plt.suptitle(self.result['dataset'], fontsize = 20)\n for id, type in enumerate(self.result) :\n if type == 'dataset' : continue\n plt.subplot(3, 3, id)\n self.draw_table(self.result[type], type)\n plt.tight_layout(pad = 1, h_pad = -0.5, w_pad = -2)\n plt.show()\ndef main() :",
"score": 61.268509076657644
},
{
"filename": "Evals/conEval.py",
"retrieved_chunk": "def get_score(para, TYPE = 'prompt') :\n gt_result, changed_result, SUM = {}, {}, 0\n gt_result['ori'] = {'score' : 0}\n for id in para : \n SUM += len(para[id]['answer'])\n for _ in range(len(para[id]['answer'])) :\n if para[id]['answer'][_] == 'GroundTruth' : gt_result['ori']['score'] += 1\n for index, opt in enumerate(para[id]['new_passage']) :\n if str(index+1) not in gt_result : \n gt_result[str(index+1)], changed_result[str(index+1)] = {'score' : 0}, {'score' : 0}",
"score": 38.38463390168453
},
{
"filename": "Evals/conEval.py",
"retrieved_chunk": " changed_result[key]['score'] = changed_result[key]['score']/SUM*100\n return gt_result, changed_result, SUM\nif __name__ == '__name__' :\n pass",
"score": 37.537144110779245
}
] | python | draw_table(error_rate, changed_rate, SUM) |
import argparse
import json
import interpreter
from Evals import get_path, conEval, robEval, creEval
import matplotlib.pyplot as plt
class Evaluator :
def __init__(
self
):
self.data = {}
self.para = {}
self.label = ''
def read_data(self, indir) :
self.data = json.load(open(indir, encoding = 'utf-8'))
return self.data
def get_label(self, str) :
str = str.split('\\')[-1]
self.label = str[:str.find('.')]
def read_para(self, type = 'robustness', res_dir = None) :
indir = 'Datasets\Attacker_out\\'+type+'\\'+self.label+'.json'
self.para = json.load(open(indir, encoding = 'utf-8'))
if res_dir != None :
self.interpreter = interpreter.Interpreter()
self.para = self.interpreter.get_llm_answer(self.para, res_dir)
def get_answerpath(self) :
self.para = get_path.get_path(self.para, self.data)
def eval(self, type) :
print(self.label)
if type == 'robustness' :
plt.figure(figsize=(10, 6), dpi=80)
plt.suptitle(type+self.label, fontsize = 20)
error_rate, changed_rate, SUM = robEval.get_score(self.para)
print('ER score:', '\n', error_rate, '\n\n',
'ASR score:', changed_rate, '\n\n', 'sum: ', SUM)
robEval.draw_table(error_rate, changed_rate, SUM)
plt.tight_layout()
plt.show()
elif type == 'consistency' :
gt_result, changed_result, SUM = conEval.get_score(self.para)
print('Groundtruth:', '\n', gt_result, '\n\n',
'Attacked:', changed_result, '\n\n', 'sum: ', SUM)
elif type == 'credibility' :
plt.figure(figsize=(10, 6), dpi=80)
plt.suptitle(type+self.label, fontsize = 20)
Rate_list = creEval. | get_rate(self.para).copy() |
SUM = 0
for key in Rate_list :
Rate_list[key] = round(sum([i for i in Rate_list[key]])/len(Rate_list[key]), 3)
SUM += Rate_list[key]
print('RTI score in '+self.label+' : '+round(SUM/3, 3))+'\\\\'
plt.show()
def process(self, config) :
self.read_data(config['indir'])
self.get_label(config['indir'])
self.read_para(config['type'], config['res_dir'])
self.get_answerpath()
self.eval(config['type'])
def main() :
parser = argparse.ArgumentParser()
parser.add_argument(
"--indir",
type = str,
nargs = "?",
default = None,
help = "input directory"
)
parser.add_argument(
"--response_dir",
type = str,
nargs = "?",
default = None,
help = "response directory"
)
parser.add_argument(
"--type",
type = str,
nargs = "?",
default = "robustness",
help = "test type including robusteness, consistency and credibility"
)
opt = parser.parse_args()
config = {
'type' : opt.type,
'indir' : opt.indir,
'res_dir' : opt.response_dir
}
evaluator = Evaluator()
evaluator.process(config)
if __name__ == '__main__' :
main() | eval.py | ZJUM3-LLMEval_RCC-a731888 | [
{
"filename": "Analysor/analysis_pos_parser.py",
"retrieved_chunk": " plt.figure(figsize=(10, 8), dpi=80)\n plt.rcParams.update({'font.size': 20})\n # plt.suptitle(self.result['dataset'], fontsize = 20)\n for id, type in enumerate(self.result) :\n if type == 'dataset' : continue\n plt.subplot(3, 3, id)\n self.draw_table(self.result[type], type)\n plt.tight_layout(pad = 1, h_pad = -0.5, w_pad = -2)\n plt.show()\ndef main() :",
"score": 65.2778453245263
},
{
"filename": "Evals/conEval.py",
"retrieved_chunk": "def get_score(para, TYPE = 'prompt') :\n gt_result, changed_result, SUM = {}, {}, 0\n gt_result['ori'] = {'score' : 0}\n for id in para : \n SUM += len(para[id]['answer'])\n for _ in range(len(para[id]['answer'])) :\n if para[id]['answer'][_] == 'GroundTruth' : gt_result['ori']['score'] += 1\n for index, opt in enumerate(para[id]['new_passage']) :\n if str(index+1) not in gt_result : \n gt_result[str(index+1)], changed_result[str(index+1)] = {'score' : 0}, {'score' : 0}",
"score": 47.90957875726783
},
{
"filename": "Evals/conEval.py",
"retrieved_chunk": " changed_result[key]['score'] = changed_result[key]['score']/SUM*100\n return gt_result, changed_result, SUM\nif __name__ == '__name__' :\n pass",
"score": 43.70680962712194
},
{
"filename": "Analysor/analysis_pos_parser.py",
"retrieved_chunk": " plt.xlabel('Type', fontsize = 25)\n plt.ylabel('Frequency',fontsize = 25)\n # plt.ylabel('Changed Rate')\n num = max([rate_result[key] for key in rate_result.keys()])\n if type == 'word_level_ri' : Type = 'word_level_insert'\n elif type == 'word_level_rd' : Type = 'word_level_delete'\n elif type == 'word_level_rp' : Type = 'word_level_replace'\n else : Type = type\n plt.title(Type, fontsize = 25)\n plt.xticks(np.arange(len(rate_result)), keys)",
"score": 39.19000255379302
},
{
"filename": "Evals/conEval.py",
"retrieved_chunk": " for __, answer in enumerate(opt['answer']) :\n if answer == 'GroundTruth' : gt_result[str(index+1)]['score'] += 1\n if para[id]['answer'][__] != answer : changed_result[str(index+1)]['score'] += 1\n if TYPE == 'prompt' :\n for key in gt_result :\n if key == 'ori' : continue\n gt_result[key]['prompt'] = changed_result[key]['prompt'] = para['0']['new_prompt'][int(key)-1]['prompt']\n for key in gt_result :\n gt_result[key]['score'] = gt_result[key]['score']/SUM*100\n if key == 'ori' : continue",
"score": 38.66482466583025
}
] | python | get_rate(self.para).copy() |
import argparse
import json
import interpreter
from Evals import get_path, conEval, robEval, creEval
import matplotlib.pyplot as plt
class Evaluator :
def __init__(
self
):
self.data = {}
self.para = {}
self.label = ''
def read_data(self, indir) :
self.data = json.load(open(indir, encoding = 'utf-8'))
return self.data
def get_label(self, str) :
str = str.split('\\')[-1]
self.label = str[:str.find('.')]
def read_para(self, type = 'robustness', res_dir = None) :
indir = 'Datasets\Attacker_out\\'+type+'\\'+self.label+'.json'
self.para = json.load(open(indir, encoding = 'utf-8'))
if res_dir != None :
self.interpreter = interpreter.Interpreter()
self.para = self.interpreter.get_llm_answer(self.para, res_dir)
def get_answerpath(self) :
self.para = get_path.get_path(self.para, self.data)
def eval(self, type) :
print(self.label)
if type == 'robustness' :
plt.figure(figsize=(10, 6), dpi=80)
plt.suptitle(type+self.label, fontsize = 20)
error_rate, changed_rate, SUM = robEval. | get_score(self.para) |
print('ER score:', '\n', error_rate, '\n\n',
'ASR score:', changed_rate, '\n\n', 'sum: ', SUM)
robEval.draw_table(error_rate, changed_rate, SUM)
plt.tight_layout()
plt.show()
elif type == 'consistency' :
gt_result, changed_result, SUM = conEval.get_score(self.para)
print('Groundtruth:', '\n', gt_result, '\n\n',
'Attacked:', changed_result, '\n\n', 'sum: ', SUM)
elif type == 'credibility' :
plt.figure(figsize=(10, 6), dpi=80)
plt.suptitle(type+self.label, fontsize = 20)
Rate_list = creEval.get_rate(self.para).copy()
SUM = 0
for key in Rate_list :
Rate_list[key] = round(sum([i for i in Rate_list[key]])/len(Rate_list[key]), 3)
SUM += Rate_list[key]
print('RTI score in '+self.label+' : '+round(SUM/3, 3))+'\\\\'
plt.show()
def process(self, config) :
self.read_data(config['indir'])
self.get_label(config['indir'])
self.read_para(config['type'], config['res_dir'])
self.get_answerpath()
self.eval(config['type'])
def main() :
parser = argparse.ArgumentParser()
parser.add_argument(
"--indir",
type = str,
nargs = "?",
default = None,
help = "input directory"
)
parser.add_argument(
"--response_dir",
type = str,
nargs = "?",
default = None,
help = "response directory"
)
parser.add_argument(
"--type",
type = str,
nargs = "?",
default = "robustness",
help = "test type including robusteness, consistency and credibility"
)
opt = parser.parse_args()
config = {
'type' : opt.type,
'indir' : opt.indir,
'res_dir' : opt.response_dir
}
evaluator = Evaluator()
evaluator.process(config)
if __name__ == '__main__' :
main() | eval.py | ZJUM3-LLMEval_RCC-a731888 | [
{
"filename": "Analysor/analysis_pos_parser.py",
"retrieved_chunk": " plt.figure(figsize=(10, 8), dpi=80)\n plt.rcParams.update({'font.size': 20})\n # plt.suptitle(self.result['dataset'], fontsize = 20)\n for id, type in enumerate(self.result) :\n if type == 'dataset' : continue\n plt.subplot(3, 3, id)\n self.draw_table(self.result[type], type)\n plt.tight_layout(pad = 1, h_pad = -0.5, w_pad = -2)\n plt.show()\ndef main() :",
"score": 62.48862475111043
},
{
"filename": "processor.py",
"retrieved_chunk": " self.para = self.attacker.process(type = config['type'], dict = self.data, \n outdir = outdir, p_dir = config['p_dir'], \n iter = config['iter'], cred = config['cred'])\n print('Attacked form data is stored in \\''+outdir+'\\'')\n def question_interpreter(self, config, type = 'robustness') :\n self.interpreter = interpreter.Interpreter()\n if not config['use_chatgpt'] : outdir = 'Datasets\\Queation_out\\\\'+type+'\\\\'+self.label+'.json'\n else : outdir = 'Datasets\\Interpreter_out\\\\'+type+'\\\\'+self.label+'_question.json'\n para = self.interpreter.process(type = type, dict_para = self.para, dict_data = self.data,\n indir_prompt = config['p_dir'], api_key = config['api_key'],",
"score": 51.462287219663175
},
{
"filename": "Evals/robEval.py",
"retrieved_chunk": "import matplotlib.pyplot as plt\nimport numpy as np\nimport math\ndef get_score(para) :\n rate_result, rate_sum, error_rate = {}, {}, {}\n changed_rate = {}\n error_rate['ori'], SUM = {0 : 0}, 0\n for id in para : \n SUM += len(para[id]['answer'])\n for _ in range(len(para[id]['answer'])) :",
"score": 50.149733821421655
},
{
"filename": "interpreter.py",
"retrieved_chunk": " i += 1\n total_time = end-start\n print(\"total time \", total_time)\n return self.para\n def get_llm_answer(self, para, res_dir) :\n res = json.load(open(res_dir, encoding = 'utf-8'))\n for id in para :\n self.para[id]['response'] = res[i]\n i += 1\n if 'new_passage' in para[id] :",
"score": 45.17847530218429
},
{
"filename": "processor.py",
"retrieved_chunk": "import argparse\nimport json\nimport converter, generator, attacker, interpreter\nclass Processor :\n def __init__(\n self\n ):\n self.data = {}\n self.para = {}\n self.label = ''",
"score": 40.99749870618646
}
] | python | get_score(self.para) |
"""Unit test for seqrecord's functionalities"""
import unittest
from typing import Dict, List
import numpy as np
import numpy.testing as nptest
from seqrecord.robot.seqrecord import RSeqRecord
def concate_list(file2segment_item: Dict[str, list]):
res = []
for key in sorted(file2segment_item):
res = res + file2segment_item[key]
return res
class Test_RSeqRecord(unittest.TestCase):
def test_encode_decode(self):
"""Testing encode and decode of items, no segment involved."""
record, dataset, features = build_simple_dataset()
# encode dataset
for i, item in enumerate(dataset):
if i % 4 == 0:
# mock start of a sequence
record. | write_item(item, True) |
else:
record.write_item(item, False)
record.close_recordfile()
record.dump()
# decode dataset
for i, item in enumerate(record.read_frames(features=features)):
for feature in features:
nptest.assert_equal(
item[feature], dataset[i][feature], err_msg="", verbose=True
)
loaded_record = RSeqRecord.load_record_from_dict("./output/seqrecord_test/")
def test_idx4segment(self):
"""Having the record written (and various attributes setup), generate an index protocal for
specific segment len."""
record, dataset, features = build_simple_dataset()
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
# segment len =2, sequence len =4, full features
seg_len = 2
idx4segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(idx4segment["file2segment_items"])
self.assertEqual(len(items), 10)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, list(range(10)))
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 2, 4, 5, 6, 8]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =4, sequence len =4, full features
seg_len = 4
idx4segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 4]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =3, sequence len =4, full feature
seg_len = 3
idx4segment = record.get_metadata4segment(segment_len=seg_len)
self.assertEqual(len(ids), 8)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 4, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
def test_idx4segment_brokenfeatures(self):
"""Test the idx4segment with some features from dataset missing."""
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 4])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
seg_len = 3
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["A100"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(items), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
seg_len = 3
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["A100"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["i5", "s1"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 1, 4, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["i5", "s1"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 3)
self.assertListEqual(ids, [0, 1, 2])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([2, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 0)
def build_simple_dataset():
"""Generate a fake dataset to test methods of Record.
Returns:
_type_: _description_
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_broken_dataset(feature_is_none_list: List[int]):
"""Generate a fake dataset to test methods of SeqRecord where some features does not exist.
Params:
feature_is_none_list (List[str]): indices of data-frame that have missing features
Returns:
None
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
if feature != "A100" or (i not in feature_is_none_list):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
else:
dataset[i][feature] = np.array(None)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_seq_dataset():
"""Generate an aritificial dataset to test methods of SeqRecord, w"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
for i in range(seq_len):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
if __name__ == "__main__":
np.random.seed(0)
unittest.main()
| seqrecord/robot/tests/test_seqrecord.py | microsoft-seqrecord-55c8d91 | [
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " )\n print(\"num_input_target_pairs: \", num_input_target_pairs)\n return num_input_target_pairs\nclass TestWSeqRecord(unittest.TestCase):\n def test_encode_decode(self):\n \"\"\"Testing encode and decode of frames.\"\"\"\n print(\"testing reading frame\")\n test_iter_frames(1e4)\n test_iter_frames(1e6)\n test_iter_frames(1e8)",
"score": 43.45773885913535
},
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " wseqrecord.MAX_RECORDFILE_SIZE = file_size\n # encode dataset\n record.put_frame(frame_generator=iter(dataset))\n record.dump_record()\n # loaded_record = WSeqRecord.load_record_from_dict(\"./output/wseqrecord_test/\")\n # decode dataset\n for i, item in enumerate(record.iterate_frames(features=features)):\n for feature in features:\n nptest.assert_equal(\n item[feature], dataset[i][feature], err_msg=\"\", verbose=True",
"score": 38.60185762579508
},
{
"filename": "seqrecord/weather/test/test_wseqrecord_mp.py",
"retrieved_chunk": "from itertools import islice\nfrom multiprocessing import Process\nclass TestWSeqRecord(unittest.TestCase):\n def test_read_frame(self):\n print(\"Test read frame\")\n dataset, rootdir, features = build_weather_dataset()\n record = parallel_write(dataset, rootdir, num_processes=3)\n for i, item in enumerate(record.iterate_frames(features=features)):\n for feature in features:\n nptest.assert_equal(",
"score": 31.464426673725985
},
{
"filename": "seqrecord/weather/test/test_wseqrecord_dist.py",
"retrieved_chunk": "from itertools import islice\nfrom multiprocessing import Process\nclass TestWSeqRecord(unittest.TestCase):\n def test_read_frame(self):\n print(\"Test read frame\")\n num_nodes, num_processes = 2, 3\n record, dataset, rootdir, features = distributed_write(num_nodes, num_processes)\n for i, item in enumerate(record.iterate_frames(features=features)):\n for feature in features:\n nptest.assert_equal(",
"score": 29.357936680926638
},
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " # loaded_record = WSeqRecord.load_record_from_dict(\"./output/wseqrecord_test/\")\n # decode dataset\n for i, item in enumerate(record.iterate_frames(features=features)):\n for feature in features:\n nptest.assert_equal(\n item[feature], dataset[i][feature], err_msg=\"\", verbose=True\n )\ndef test_read_framepairs_from_file(file_size: int, max_pred_steps: int):\n assert max_pred_steps > 1, \"maximum prediction steps need to be greater than 1\"\n dataset, record, features = build_weather_dataset()",
"score": 28.736400485653633
}
] | python | write_item(item, True) |
"""transform existing weather dataset to sequence weather format.
"""
from seqrecord.weather.seqrecord import WSeqRecord
import os
from typing import List
import re
import numpy as np
from tqdm import tqdm
# test correctness of saved seqrecord format
# dataset: 5.625deg_equally_np_all_levels, 1.40625deg_equally_np_all_levels(ultimate goal)
DEFAULT_CONFIG = {
"dataset_mount_dir": "/datadrive/weatherdatastorage2/datasets", # "/datadrive/weatherdatastorage2/datasets", # "/mnt/data",
"wsrecord_dir": "CMIP6/MPI-ESM/wseqrecord/test/1.40625deg_equally_np_all_levels/train/",
"wdataset_dir": "CMIP6/MPI-ESM/1.40625deg_equally_np_all_levels/train/",
"wdataset_split": "train",
}
def sort_weatherfiles(files: List[os.DirEntry]) -> List[os.DirEntry]:
"""Return sorted files in dir, make sure files are sorted incrementally in time.
# todo: check with Jayesh this sorting is correct
Example file names: 195001010600-195501010000_33.npz from CMIP6/MPI-ESM/1.40625deg_equally_np_all_levels/train/
Args:
files (List[os.DirEntry]): each element in list is a file name
"""
def str2nums(direntry):
nums = re.split("-|_", direntry.name.split(".")[0])
nums = tuple(map(int, nums))
return nums
return sorted(files, key=str2nums)
def main(config: dict) -> None:
wsrecord = WSeqRecord(
os.path.join(config["dataset_mount_dir"], config["wsrecord_dir"])
)
files_dirs = os.scandir(
os.path.join(config["dataset_mount_dir"], config["wdataset_dir"])
)
files = list(filter(lambda direntry: direntry.is_file(), files_dirs))
files = sort_weatherfiles(files)
def frame_generator(files):
i = 0
for file_path in tqdm(files):
if i >= 50:
break
data = np.load(file_path)
num_frames = data[data.files[0]].shape[0]
for rel_frame_idx in range(num_frames):
frame = {}
for key in data.files:
frame[key] = data[key][rel_frame_idx]
yield frame
i += 1
wsrecord. | put_frame(frame_generator(files), 5) |
wsrecord.dump()
if __name__ == "__main__":
config = DEFAULT_CONFIG
main(config)
| seqrecord/weather/format/weathernp2seq.py | microsoft-seqrecord-55c8d91 | [
{
"filename": "seqrecord/weather/format/weathernp2seq_mp.py",
"retrieved_chunk": " for rel_frame_idx in range(num_frames):\n frame = {}\n for key in data.files:\n frame[key] = data[key][rel_frame_idx]\n yield frame\n i += 1\n sub_wsrecord.put_frame(frame_generator(sub_weatherfile_generator), 5)\n sub_wsrecord.dump(rank)\ndef distribute_loads(works: int, num_processes: int) -> List[Tuple[int, int]]:\n \"\"\"Given the overall works and number of processes, allocate evenly the loads that each process should take.",
"score": 66.10232174536266
},
{
"filename": "seqrecord/weather/format/weathernp2seq_mp.py",
"retrieved_chunk": " def frame_generator(files: Iterator):\n i = 0\n pbar = (\n tqdm(files, desc=\"Formatting progress on rank 0:\", total=sub_loads)\n if rank == 0\n else files\n )\n for file_path in pbar:\n data = np.load(file_path)\n num_frames = data[data.files[0]].shape[0]",
"score": 55.68086175035146
},
{
"filename": "seqrecord/robot/seqrecord.py",
"retrieved_chunk": " is_seq_start: bool,\n ) -> None:\n \"\"\"write one item data dict(feature->np.ndarray) into bytes and write encoded bytes into\n current record files.\n Args:\n item (Dict[str, np.ndarray]): feature to data (np.ndarray)\n is_seq_start (bool): denote if the item is the beginning of a sequence\n \"\"\"\n if self.features_written is None:\n self.features_written = [key for key in frame]",
"score": 32.55888263814769
},
{
"filename": "seqrecord/weather/format/grib2seqrecord.py",
"retrieved_chunk": " np_vars[f\"{var}_{level}\"] = ds[code].to_numpy()\n del ds\n # assert np_vars[f\"{var}_{level}\"].shape[0] == HOURS_PER_MONTH\n for i in range(num_frames_in_month):\n frame = {}\n for key in np_vars:\n frame[key] = np_vars[key][i]\n yield frame\ndef grib2np(record, config, year):\n \"\"\"",
"score": 30.48580590374181
},
{
"filename": "seqrecord/weather/seqrecord.py",
"retrieved_chunk": " num_bytes_in_frame = 0\n for feature, data in frame.items():\n self.meta_frame[frame_idx][feature] = {\n \"is_none\": (\n data.dtype == np.dtype(\"O\") and data == None\n ), # this feature is essentially missing, and\n \"dtype\": data.dtype,\n \"shape\": data.shape,\n \"bytes_offset\": num_bytes_in_frame,\n \"nbytes\": data.nbytes,",
"score": 29.618116012044414
}
] | python | put_frame(frame_generator(files), 5) |
"""A package for decoding and encoding each item in data file."""
import collections
import io
import os
import pickle
from typing import (
Any,
BinaryIO,
Dict,
Generator,
List,
Optional,
Sequence,
Tuple,
TypeVar,
Union,
Deque,
)
import numpy as np
import yaml
from seqrecord.utils import WriterBuffer
import copy
from collections import deque
import time
from seqrecord.utils import PRODUCER_SLEEP_INTERVAL, CONSUMER_SLEEP_INTERVAL
import threading
MAX_RECORDFILE_SIZE = 1e9 # 1e8, 100 mb, maximum size of a single record file
RSR = TypeVar("RSR", bound="RSeqRecord")
def recordfileidx2path(recorddir, recordfile_idx: int) -> str:
return os.path.join(recorddir, f"records_{recordfile_idx}.bin")
# todo: add metadata for each episode
class RSeqRecord:
"""A serialization protocal that stores sequences of episodes into record files, while provides metadata of each episode/frame
to read segments from dataset."""
def __init__(
self,
recorddir: str,
) -> None:
# folder that stores data in a separate directory (subfolder)
self.recorddir: str = recorddir
os.makedirs(self.recorddir, exist_ok=True)
self.features_written = None
self.num_bytes: int = 0 # number of bytes written into current record file
self.file_idx: int = 0 # number of record file created for dataset
# track the idx endpoints for each record file, [[start_idx, end_idx]], both are inclusive
self.idx_range_of_files: List[Tuple[int, int]] = []
# file object for current record file
self.file_desc: Optional[BinaryIO] = None
# serialization proto info of each data item
self.metadata: Dict[int, dict] = {}
# index of current data item to be processed
self.frame_idx: int = 0
# a cache dict that stores protocal info for each (segment_len, sub features)
self.metadata_segment_cache: Dict[str, dict] = {}
self.write_buffer = WriterBuffer()
def get_recordfiles(self) -> List[str]:
return [self.recordfile_idx_to_path(i) for i in range(self.file_idx)]
def write_item(
self,
frame: Dict[str, np.ndarray],
is_seq_start: bool,
) -> None:
"""write one item data dict(feature->np.ndarray) into bytes and write encoded bytes into
current record files.
Args:
item (Dict[str, np.ndarray]): feature to data (np.ndarray)
is_seq_start (bool): denote if the item is the beginning of a sequence
"""
if self.features_written is None:
self.features_written = [key for key in frame]
if is_seq_start:
self.seq_start()
# get file name and start position for item
self.metadata[self.frame_idx] = {
"frame_idx": self.frame_idx,
"file_idx": self.file_idx,
"bytes_offset": self.num_bytes,
"is_seq_start": is_seq_start,
}
num_bytes_in_frame = 0
for feature, data in frame.items():
self.metadata[self.frame_idx][feature] = {
"is_none": (
data.dtype == np.dtype("O") and data == None
), # this feature is essentially missing, and
"dtype": data.dtype,
"shape": data.shape,
"bytes_offset": num_bytes_in_frame,
"nbytes": data.nbytes,
}
self.write_buffer.write(data.tobytes())
num_bytes_in_frame += data.nbytes
self.num_bytes += num_bytes_in_frame
self.frame_idx += 1
return
def seq_start(self) -> None:
"""Notify the record that a new sequence is being written, let the record decide if we need
a new record file to write into.
Two cases we need to open new file:
1. we currently do not have record file to write into
2. current file size is big enough (larger than MAX_RECORDFILE_SIZE)
"""
if self.num_bytes > MAX_RECORDFILE_SIZE:
# current record file big enough
self.num_bytes = 0
self.file_idx += 1
self.idx_range_of_files[-1].append(self.frame_idx - 1)
self.idx_range_of_files.append([self.frame_idx])
self.file_desc.write(self.write_buffer. | getbuffer()) |
self.file_desc.flush()
self.file_desc.close()
self.write_buffer.clear()
self.file_desc = open(
recordfileidx2path(self.recorddir, self.file_idx),
mode="wb",
)
elif self.file_desc == None:
# no opened record file to write into
self.idx_range_of_files.append([self.frame_idx])
self.file_desc = open(
recordfileidx2path(self.recorddir, self.file_idx), mode="wb"
)
def read_frame(
self,
file_desc: Union[io.BufferedReader, BinaryIO],
metadata_frame: Dict[str, Union[int, dict]],
features: List[str],
) -> Dict[str, np.ndarray]:
"""Given record file descriptor and serialization proto of a single data item, return the
decoded dictionary(feature->data(np.ndarray)) of the item.
Args:
recordfile_desc (io.BufferedReader): python file object of the record file (required by numpy)
itemproto (Dict[str, Any]): dict that contains protocal info of a specific data item
Returns:
Dict[str, np.ndarray]: data
"""
frame = {}
frame_offset = metadata_frame["bytes_offset"]
for feature in features:
frame[feature] = np.memmap(
file_desc,
dtype=metadata_frame[feature]["dtype"],
mode="r",
offset=frame_offset + metadata_frame[feature]["bytes_offset"],
shape=metadata_frame[feature]["shape"],
)
# * do we need to close the memmap?
return frame
def read_frame_frombuffer(
self,
file_desc: Union[io.BufferedReader, BinaryIO],
metadata_frame: Dict[str, Union[int, dict]],
features: List[str],
) -> Dict[str, np.ndarray]:
"""Given record file descriptor and serialization proto of a single data item, return the
decoded dictionary(feature->data(np.ndarray)) of the item, where decoding is done by
np.frombuffer()
Args:
recordfile_desc (io.BufferedReader): python file object of the record file (required by numpy)
itemproto (Dict[str, Any]): dict that contains protocal info of a specific data item
Returns:
Dict[str, np.ndarray]: data
"""
frame = {}
file_desc.seek(metadata_frame["bytes_offset"])
for feature in features:
bytes = file_desc.read(metadata_frame[feature]["nbytes"])
array1d = np.frombuffer(
bytes,
dtype=metadata_frame[feature]["dtype"],
)
frame[feature] = array1d.reshape(metadata_frame[feature]["shape"])
return frame
def read_frames(
self, features: List[str]
) -> Generator[Dict[str, np.ndarray], None, None]:
"""Given that the dataset has been recored, decode the record sequentially, each time
returning a dict that contains the data item.
Args:
features [List[str]]: a list of features requested to read from item
shuffle_recordfile: bool: if we shuffle at the record file level when reading items in the record
Yields:
Generator[Dict[str, np.ndarray], None, None]: data item [feature->data]. All data items are being returned sequentially
"""
recordfiles = list(range(self.file_idx))
for i in recordfiles:
recordfile_path = recordfileidx2path(self.recorddir, i)
endpoints = self.idx_range_of_files[i]
with open(recordfile_path, mode="rb") as f:
for idx in range(endpoints[0], endpoints[1] + 1):
item = self.read_frame(f, self.metadata[idx], features)
yield {feature: item[feature] for feature in features}
def get_metadata4segment(
self, segment_len: int, sub_features: Optional[List[str]] = None
) -> Dict[str, Any]:
"""Generate a protocal for reading segments from records. Each data item of segment should
contain all features in sub_features.
Note:
Only call this function when record has scanned all data in dataset, and record has valid attributes: rootdir, recordfile_idx
Args:
segment_len (int): length of segment we are reading, 1< segment_len < sequence length
sub_features: (Optional[List[str]]): features (modalities data) we need for each data item in segment to contain. If it is None,
then we read all features.
Returns:
Dict[str, Any]: protocal needed for reading segments from data
"""
def has_sub_features(itemproto: Dict[str, Any]) -> bool:
return all(not itemproto[feature]["is_none"] for feature in sub_features)
def update_segmentproto(item_idx: int, is_segment_start: bool) -> None:
if is_segment_start:
head4segment.append(item_idx)
recordfile_idx = self.metadata[item_idx]["file_idx"]
file2segment_items[recordfile_idx].append((is_segment_start, item_idx))
return
if sub_features is None:
sub_features = list(self.features_written)
else:
assert all(
feature in self.features_written for feature in sub_features
), "Unknow features requested"
cache_key = str(segment_len) + "#" + "#".join(sorted(sub_features))
if cache_key in self.metadata_segment_cache:
return self.metadata_segment_cache[cache_key]
head4segment: List[int] = []
file2segment_items: dict[int, List[Tuple[bool, int]]] = collections.defaultdict(
list
)
q = collections.deque()
q_has_seg_tail = False # indicates if the elements currently in queue are tail of some segment
for idx in range(self.frame_idx):
itemproto = self.metadata[idx]
if (not has_sub_features(itemproto)) or (itemproto["is_seq_start"]):
# new seq start
while q:
if q_has_seg_tail:
update_segmentproto(q.popleft(), is_segment_start=False)
else:
q.popleft()
q_has_seg_tail = False
if has_sub_features(itemproto):
# a valid start of sequence
q.append(idx)
else:
q.append(idx)
if len(q) == segment_len:
# claim: elements in the queue must be from the same sequence
update_segmentproto(q.popleft(), is_segment_start=True)
q_has_seg_tail = True
if q and q_has_seg_tail:
# front element in queue is need as last element of some segment
update_segmentproto(q.popleft(), is_segment_start=False)
# 1. new seq (including broken) added before queue pops out
# the remaining elements in queue are completely useless
# 2. new seq (including broken) added after queue has popped out
# the remaining elements are not start of segment but are tails of some segment
self.metadata_segment_cache[cache_key] = {
"segment_len": segment_len,
"features": sub_features,
"head4segment": head4segment,
"file2segment_items": file2segment_items,
}
return self.metadata_segment_cache[cache_key]
def read_segments(self, segment_proto: dict):
"""Iterate through the whole records and return segments sequential.
Yields:
segment_proto: info on in given segment_len and features
"""
segment_len = segment_proto["segment_len"]
recordfile_ids = list(segment_proto["file2segment_items"].keys())
for recordfile_idx in recordfile_ids:
item_list = segment_proto["file2segment_items"][recordfile_idx]
recordfile_path = recordfileidx2path(self.recorddir, recordfile_idx)
q = collections.deque()
with open(recordfile_path, mode="rb") as f:
for is_segment_start, item_idx in item_list:
q.append(
(
is_segment_start,
self.read_frame(
f, self.metadata[item_idx], segment_proto["features"]
),
)
)
while not q[0][0]:
q.popleft()
if len(q) == segment_len:
yield self.collate_items(q)
q.popleft()
def read_one_segment(
self,
segment_len: int,
head_idx: int,
) -> Dict[str, List[np.ndarray]]:
"""Read a segment (of lenght segment_len) starting from the item index being head_idx.
Args:
segment_len (int): length of segment we need to generate
head_idx (int): item_idx of the head of the segment to be read.
Returns:
Dict[str, np.ndarray]: segment data
"""
recordfile_path = recordfileidx2path(
self.recorddir, self.metadata[head_idx]["recordfile_idx"]
)
q = []
with open(recordfile_path, mode="rb") as f:
for idx in range(head_idx, head_idx + segment_len):
q.append(
(
idx == head_idx,
self.read_frame_frombuffer(f, self.metadata[idx]),
)
)
return self.collate_items(q)
def collate_items(
self, q: Sequence[Tuple[bool, dict]]
) -> Dict[str, List[np.ndarray]]:
segment = {}
features = q[0][1].keys()
for feature in features:
segment[feature] = [item[feature] for _, item in q]
return segment
def close_recordfile(self):
"""Close opened file descriptor!
This needs to be called when finishes scanning over the dataset.
"""
self.idx_range_of_files[-1].append(self.frame_idx - 1)
self.file_desc.write(self.write_buffer.getbuffer())
self.write_buffer.close()
self.write_buffer = None
self.file_desc.flush()
self.file_desc.close()
self.file_idx += 1
self.file_desc = None
def dump(self) -> None:
"""save attributes of instance of record into a file.
Note:
saving attribute dict instead of pickled class: pickling class and loading it is a mess because of
path issues.
"""
dic = copy.deepcopy(self.__dict__)
with open(os.path.join(self.recorddir, "record.dict"), mode="wb") as f:
pickle.dump(dic, file=f)
# save some attributes of the seqrecord to yaml for human inspection
dic["metadata_segment_cache"] = None
for key, val in dic["metadata"].items():
for feature in dic["features_written"]:
val[feature]["dtype"] = val[feature]["dtype"].str
val[feature]["shape"] = list(val[feature]["shape"])
with open(os.path.join(self.recorddir, "record_dict.yaml"), mode="w") as f:
f.write("# Configs for human inspection only!\n")
f.write(yaml.dump(dic))
@classmethod
def load_record_from_dict(cls, recorddir: str) -> RSR:
"""return an instance of sequence record from file that stores attributes of record as a
dict (stored at path).
Args:
path (str): path to the file that stores dict of attributes of seqrecord
Returns:
SR: an instance of record
"""
file_path = os.path.join(recorddir, "record.dict")
with open(file_path, mode="rb") as f:
obj_dict = pickle.load(f)
obj = cls(
recorddir=recorddir,
)
obj_dict.pop("recorddir", None)
for key, value in obj_dict.items():
setattr(obj, key, value)
return obj
| seqrecord/robot/seqrecord.py | microsoft-seqrecord-55c8d91 | [
{
"filename": "seqrecord/weather/seqrecord.py",
"retrieved_chunk": " }\n write_buffer.write(data.tobytes())\n num_bytes_in_frame += data.nbytes\n self.meta_frame[frame_idx][\"nbytes\"] = num_bytes_in_frame\n frame_idx += 1\n num_bytes += num_bytes_in_frame\n if num_bytes > MAX_RECORDFILE_SIZE:\n # current file is big enough\n num_bytes = 0\n self.meta_file[file_idx][\"frame_idx_end\"] = frame_idx",
"score": 108.33613242067456
},
{
"filename": "seqrecord/weather/seqrecord.py",
"retrieved_chunk": " write_buffer = WriterBuffer()\n num_bytes = 0\n self.meta_file = {}\n self.meta_frame = {}\n frame_idx = 0\n file_idx = 0\n for frame in frame_generator:\n if self.features_written is None:\n self.features_written = [key for key in frame]\n if num_bytes == 0:",
"score": 50.61513753156724
},
{
"filename": "seqrecord/weather/seqrecord.py",
"retrieved_chunk": " # new file\n self.meta_file[file_idx] = {\n \"frame_idx_start\": frame_idx,\n \"relative_path\": self.fileidx2name(file_idx),\n }\n # relative path to the record file does not contain directory of the corresponding seqrecord\n self.meta_frame[frame_idx] = {\n \"file_idx\": file_idx,\n \"bytes_offset\": num_bytes,\n }",
"score": 49.071591483450206
},
{
"filename": "seqrecord/weather/seqrecord.py",
"retrieved_chunk": " and self.meta_file[file_idx].get(\"frame_idx_end\", None) is None\n ):\n # there is content left in the write_buffer\n self.meta_file[file_idx][\"frame_idx_end\"] = frame_idx\n yield (\n self.fileidx2path(file_idx, self.local_cache_dir),\n write_buffer.getvalue(),\n )\n file_idx += 1\n finally:",
"score": 40.28250499423655
},
{
"filename": "seqrecord/weather/seqrecord.py",
"retrieved_chunk": " write_buffer.clear()\n yield (\n self.fileidx2path(\n file_idx, local_cache_dir=self.local_cache_dir\n ),\n write_buffer.getvalue(),\n )\n file_idx += 1\n if (\n file_idx in self.meta_file",
"score": 34.73041036607677
}
] | python | getbuffer()) |
from seqrecord import WSeqRecord, build_wdatapipe
import torch
import numpy as np
from tqdm import tqdm
from torchdata.dataloader2 import (
DataLoader2,
DistributedReadingService,
MultiProcessingReadingService,
SequentialReadingService,
)
from time import perf_counter
import click
import torch.distributed as dist
import torch.multiprocessing as mp
import os
import sys
MASTER_ADDR = "127.0.0.1"
WORLD_SIZE = 2
import socket
def _get_open_port():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(("", 0))
port = s.getsockname()[1]
s.close()
return str(port)
os.environ["MASTER_ADDR"] = MASTER_ADDR
os.environ["MASTER_PORT"] = _get_open_port()
# constants
VAR = [
"2m_temperature",
"10m_u_component_of_wind",
"10m_v_component_of_wind",
"mean_sea_level_pressure",
"total_cloud_cover",
"total_column_water_vapour",
"geopotential_1",
"geopotential_2",
"geopotential_3",
"geopotential_5",
"geopotential_7",
"geopotential_10",
"geopotential_20",
"geopotential_30",
"geopotential_70",
"geopotential_125",
"geopotential_175",
"geopotential_225",
"geopotential_350",
"geopotential_450",
"geopotential_550",
"geopotential_650",
"geopotential_750",
"geopotential_775",
"geopotential_800",
"geopotential_825",
"geopotential_875",
"geopotential_900",
"geopotential_950",
"geopotential_975",
"specific_humidity_1",
"specific_humidity_2",
"specific_humidity_3",
"specific_humidity_5",
"specific_humidity_7",
"specific_humidity_10",
"specific_humidity_20",
"specific_humidity_30",
"specific_humidity_70",
"specific_humidity_125",
"specific_humidity_175",
"specific_humidity_225",
"specific_humidity_350",
"specific_humidity_450",
"specific_humidity_550",
"specific_humidity_650",
"specific_humidity_750",
"specific_humidity_775",
"specific_humidity_800",
"specific_humidity_825",
"specific_humidity_875",
"specific_humidity_900",
"specific_humidity_950",
"specific_humidity_975",
"temperature_1",
"temperature_2",
"temperature_3",
"temperature_5",
"temperature_7",
"temperature_10",
"temperature_20",
"temperature_30",
"temperature_70",
"temperature_125",
"temperature_175",
"temperature_225",
"temperature_350",
"temperature_450",
"temperature_550",
"temperature_650",
"temperature_750",
"temperature_775",
"temperature_800",
"temperature_825",
"temperature_875",
"temperature_900",
"temperature_950",
"temperature_975",
"u_component_of_wind_1",
"u_component_of_wind_2",
"u_component_of_wind_3",
"u_component_of_wind_5",
"u_component_of_wind_7",
"u_component_of_wind_10",
"u_component_of_wind_20",
"u_component_of_wind_30",
"u_component_of_wind_70",
"u_component_of_wind_125",
"u_component_of_wind_175",
"u_component_of_wind_225",
"u_component_of_wind_350",
"u_component_of_wind_450",
"u_component_of_wind_550",
"u_component_of_wind_650",
"u_component_of_wind_750",
"u_component_of_wind_775",
"u_component_of_wind_800",
"u_component_of_wind_825",
"u_component_of_wind_875",
"u_component_of_wind_900",
"u_component_of_wind_950",
"u_component_of_wind_975",
"v_component_of_wind_1",
"v_component_of_wind_2",
"v_component_of_wind_3",
"v_component_of_wind_5",
"v_component_of_wind_7",
"v_component_of_wind_10",
"v_component_of_wind_20",
"v_component_of_wind_30",
"v_component_of_wind_70",
"v_component_of_wind_125",
"v_component_of_wind_175",
"v_component_of_wind_225",
"v_component_of_wind_350",
"v_component_of_wind_450",
"v_component_of_wind_550",
"v_component_of_wind_650",
"v_component_of_wind_750",
"v_component_of_wind_775",
"v_component_of_wind_800",
"v_component_of_wind_825",
"v_component_of_wind_875",
"v_component_of_wind_900",
"v_component_of_wind_950",
"v_component_of_wind_975",
]
VAR4TEST = [
"2m_temperature",
"geopotential_1",
]
def identity(x):
return x
def mp_loader(dp):
rs = MultiProcessingReadingService(num_workers=4)
dl = DataLoader2(dp, reading_service=rs)
print("MP reading serivce")
num_frames = 0
for i, batch in tqdm(enumerate(dl)):
# batch_size is 1
num_frames += 1
item = batch[0]
print("\n")
for key, val in item.items():
if isinstance(val, dict):
print(key, val.keys())
elif isinstance(val, torch.Tensor):
print(key, val.size())
elif isinstance(val, np.ndarray):
print(key, val.shape)
else:
print(key, val)
print(f"num_frames: {num_frames}")
dl.shutdown()
def dist_loader(rank, world_size, dp, q):
dist.init_process_group("gloo", rank=rank, world_size=world_size)
rs = DistributedReadingService()
dl = DataLoader2(dp, reading_service=rs)
cnt = 0
for d in tqdm(dl, desc=f"loading on rank {rank}"):
cnt += 1
# Mimic distributed training step
dist.barrier()
q.put(cnt)
dl.shutdown()
def mp_dist_training(rank, world_size, dp, q):
dist.init_process_group("gloo", rank=rank, world_size=world_size)
mp_rs = MultiProcessingReadingService(num_workers=3)
dist_rs = DistributedReadingService()
rs = SequentialReadingService(dist_rs, mp_rs)
dl = DataLoader2(dp, reading_service=rs)
cnt = 0
for d in tqdm(dl, desc=f"loading on rank {rank} with mp reading service"):
cnt += 1
# Mimic distributed training step
dist.barrier()
q.put(cnt)
dl.shutdown()
def dist_run(loader, dp):
ctx = mp.get_context("fork") # Notebook doesn't work well with spawn
pqs = []
for rank in range(WORLD_SIZE):
q = ctx.Queue()
p = ctx.Process(target=loader, args=(rank, WORLD_SIZE, dp, q))
pqs.append((p, q))
p.start()
for rank in range(WORLD_SIZE):
cnt = pqs[rank][1].get()
print(f"DataLoader2 on rank {rank} received {cnt} data")
pqs[rank][0].join()
@click.command()
@click.option(
"--container-dir", default="/datadrive/azure_storage/weathereastus/era5seqrecord"
)
@click.option(
"--reading-service", required=True, type=click.Choice(["mp", "dist", "mpdist"])
)
@click.option("--testing", required=True, type=bool)
def main(container_dir: str, reading_service: str, testing: bool = True):
recorddir = f"{container_dir}/local/1980"
record = WSeqRecord. | load_record(recorddir=recorddir) |
var_list = VAR4TEST if testing else VAR
record.set_framereader_args(
{
"input_features": var_list,
"target_features": var_list,
"hours_per_step": 1,
"max_pred_steps": 10,
}
)
dp = build_wdatapipe(
[record], None, None, batch_size=1, mappings=[], collate_fn=identity
)
print(f"Testing: {testing}")
if reading_service == "mp":
print("Testing mp reading with 4 workers:")
mp_loader(dp)
elif reading_service == "dist":
print(f"Testing dist reading with {WORLD_SIZE} nodes:")
dist_run(dist_loader, dp)
else:
print(f"Testing dist mp reading with {WORLD_SIZE} nodes and 3 workers:")
dist_run(mp_dist_training, dp)
if __name__ == "__main__":
main()
| seqrecord/weather/format/validation.py | microsoft-seqrecord-55c8d91 | [
{
"filename": "seqrecord/weather/format/grib2seqrecord_mp.py",
"retrieved_chunk": " frame_generator(rank, config[\"grib_dataset_dir\"], year, month_gen)\n )\n print(\"rank\", rank, \" finished, dummping metadata!\")\n sub_wseqrecord.dump_record(rank=rank)\[email protected]()\[email protected](\n \"--dataset-mount-dir\", type=str, default=\"/datadrive/azure_storage/weathereastus\"\n)\[email protected](\"--local-cache-dir\", type=str, default=\"~/record_cache\")\[email protected](\"--year\", type=int, required=True)",
"score": 90.79941746453349
},
{
"filename": "seqrecord/weather/format/grib2seqrecord_debug.py",
"retrieved_chunk": " \"--dataset-mount-dir\", type=str, default=\"/datadrive/azure_storage/weathereastus\"\n)\[email protected](\"--year\", type=int, required=True)\[email protected](\"--num-processes\", type=int, default=6)\ndef main(dataset_mount_dir: str, year: int, num_processes: int):\n print(f\"configs {dataset_mount_dir=}, {year=}, {num_processes=}.\\n\")\n year = 1979\n # \"/datadrive/weatherdatastorage2/datasets\", # \"/mnt/data\",\n DEFAULT_CONFIG = {\n \"num_processes\": num_processes,",
"score": 81.71044601293869
},
{
"filename": "seqrecord/weather/format/grib2seqrecord.py",
"retrieved_chunk": " Convert grib files to numpy arrays and save them to disk.\n \"\"\"\n record.put_frame(frame_generator(config[\"grib_dataset_dir\"], year))\[email protected]()\[email protected](\n \"--dataset-mount-dir\", type=str, default=\"/datadrive/azure_storage/weathereastus\"\n)\[email protected](\"--year\", type=int, required=True)\ndef main(dataset_mount_dir: str, year: int):\n # dataset: 5.625deg_equally_np_all_levels, 1.40625deg_equally_np_all_levels(ultimate goal)",
"score": 77.40920114156532
},
{
"filename": "seqrecord/weather/format/grib2seqrecord_mp.py",
"retrieved_chunk": "@click.option(\"--num-processes\", type=int, default=12)\ndef main(dataset_mount_dir: str, local_cache_dir: str, year: int, num_processes: int):\n # dataset: 5.625deg_equally_np_all_levels, 1.40625deg_equally_np_all_levels(ultimate goal)\n # \"/datadrive/weatherdatastorage2/datasets\", # \"/mnt/data\",\n DEFAULT_CONFIG = {\n \"num_processes\": num_processes,\n \"local_cache_dir\": local_cache_dir,\n \"wseqrecord_dir\": os.path.join(\n dataset_mount_dir,\n f\"era5seqrecord/test/{year}\",",
"score": 46.9356690407522
},
{
"filename": "seqrecord/weather/format/post_dist.py",
"retrieved_chunk": "import os\nfrom seqrecord.weather.seqrecord import WSeqRecord\ndef main():\n years = range(1979, 2016)\n recorddir = \"/datadrive/azure_storage/weathereastus/era5seqrecord/aml_dist\"\n for year in years:\n print(f\"Gathering {year}'s data\")\n sub_dir = os.path.join(recorddir, str(year))\n WSeqRecord.gather_subseqrecords(sub_dir, 12).dump(rank=year - 1979)\n print(\"Gathering all years' data\")",
"score": 32.611384102211744
}
] | python | load_record(recorddir=recorddir) |
"""Unit test for seqrecord's functionalities"""
import unittest
from typing import Dict, List
import numpy as np
import numpy.testing as nptest
from seqrecord.robot.seqrecord import RSeqRecord
def concate_list(file2segment_item: Dict[str, list]):
res = []
for key in sorted(file2segment_item):
res = res + file2segment_item[key]
return res
class Test_RSeqRecord(unittest.TestCase):
def test_encode_decode(self):
"""Testing encode and decode of items, no segment involved."""
record, dataset, features = build_simple_dataset()
# encode dataset
for i, item in enumerate(dataset):
if i % 4 == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
record.dump()
# decode dataset
for i, item in enumerate(record.read_frames(features=features)):
for feature in features:
nptest.assert_equal(
item[feature], dataset[i][feature], err_msg="", verbose=True
)
loaded_record = RSeqRecord. | load_record_from_dict("./output/seqrecord_test/") |
def test_idx4segment(self):
"""Having the record written (and various attributes setup), generate an index protocal for
specific segment len."""
record, dataset, features = build_simple_dataset()
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
# segment len =2, sequence len =4, full features
seg_len = 2
idx4segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(idx4segment["file2segment_items"])
self.assertEqual(len(items), 10)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, list(range(10)))
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 2, 4, 5, 6, 8]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =4, sequence len =4, full features
seg_len = 4
idx4segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 4]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =3, sequence len =4, full feature
seg_len = 3
idx4segment = record.get_metadata4segment(segment_len=seg_len)
self.assertEqual(len(ids), 8)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 4, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
def test_idx4segment_brokenfeatures(self):
"""Test the idx4segment with some features from dataset missing."""
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 4])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
seg_len = 3
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["A100"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(items), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
seg_len = 3
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["A100"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["i5", "s1"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 1, 4, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["i5", "s1"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 3)
self.assertListEqual(ids, [0, 1, 2])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([2, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 0)
def build_simple_dataset():
"""Generate a fake dataset to test methods of Record.
Returns:
_type_: _description_
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_broken_dataset(feature_is_none_list: List[int]):
"""Generate a fake dataset to test methods of SeqRecord where some features does not exist.
Params:
feature_is_none_list (List[str]): indices of data-frame that have missing features
Returns:
None
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
if feature != "A100" or (i not in feature_is_none_list):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
else:
dataset[i][feature] = np.array(None)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_seq_dataset():
"""Generate an aritificial dataset to test methods of SeqRecord, w"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
for i in range(seq_len):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
if __name__ == "__main__":
np.random.seed(0)
unittest.main()
| seqrecord/robot/tests/test_seqrecord.py | microsoft-seqrecord-55c8d91 | [
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " wseqrecord.MAX_RECORDFILE_SIZE = file_size\n # encode dataset\n record.put_frame(frame_generator=iter(dataset))\n record.dump_record()\n # loaded_record = WSeqRecord.load_record_from_dict(\"./output/wseqrecord_test/\")\n # decode dataset\n for i, item in enumerate(record.iterate_frames(features=features)):\n for feature in features:\n nptest.assert_equal(\n item[feature], dataset[i][feature], err_msg=\"\", verbose=True",
"score": 64.10325437952798
},
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " # loaded_record = WSeqRecord.load_record_from_dict(\"./output/wseqrecord_test/\")\n # decode dataset\n for i, item in enumerate(record.iterate_frames(features=features)):\n for feature in features:\n nptest.assert_equal(\n item[feature], dataset[i][feature], err_msg=\"\", verbose=True\n )\ndef test_read_framepairs_from_file(file_size: int, max_pred_steps: int):\n assert max_pred_steps > 1, \"maximum prediction steps need to be greater than 1\"\n dataset, record, features = build_weather_dataset()",
"score": 58.29151815106861
},
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " item[\"target\"],\n item[\"lookahead_steps\"],\n )\n lookahead_steps_stats[lookahead_steps - 1] += 1\n x_target = np.vstack([dataset[i][feature] for feature in input_features])\n y_target = np.vstack(\n [dataset[i + lookahead_steps][feature] for feature in output_features]\n )\n nptest.assert_equal(x, x_target, err_msg=\"\", verbose=True)\n nptest.assert_equal(",
"score": 37.68692398904576
},
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " x_target = np.vstack([dataset[i][feature] for feature in input_features])\n y_target = np.vstack(\n [dataset[i + lookahead_steps][feature] for feature in output_features]\n )\n nptest.assert_equal(x, x_target, err_msg=\"\", verbose=True)\n nptest.assert_equal(\n y,\n y_target,\n err_msg=\"\",\n verbose=True,",
"score": 36.483308138850745
},
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " dataset[i + lookahead_steps][feature]\n for feature in read_args[\"target_features\"]\n ]\n )\n nptest.assert_equal(x, x_target, err_msg=\"\", verbose=True)\n nptest.assert_equal(\n y,\n y_target,\n err_msg=\"\",\n verbose=True,",
"score": 36.35231141422515
}
] | python | load_record_from_dict("./output/seqrecord_test/") |
"""Unit test for seqrecord's functionalities"""
import unittest
from typing import Dict, List
import numpy as np
import numpy.testing as nptest
from seqrecord.robot.seqrecord import RSeqRecord
def concate_list(file2segment_item: Dict[str, list]):
res = []
for key in sorted(file2segment_item):
res = res + file2segment_item[key]
return res
class Test_RSeqRecord(unittest.TestCase):
def test_encode_decode(self):
"""Testing encode and decode of items, no segment involved."""
record, dataset, features = build_simple_dataset()
# encode dataset
for i, item in enumerate(dataset):
if i % 4 == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
record.dump()
# decode dataset
for i, item in enumerate(record. | read_frames(features=features)): |
for feature in features:
nptest.assert_equal(
item[feature], dataset[i][feature], err_msg="", verbose=True
)
loaded_record = RSeqRecord.load_record_from_dict("./output/seqrecord_test/")
def test_idx4segment(self):
"""Having the record written (and various attributes setup), generate an index protocal for
specific segment len."""
record, dataset, features = build_simple_dataset()
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
# segment len =2, sequence len =4, full features
seg_len = 2
idx4segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(idx4segment["file2segment_items"])
self.assertEqual(len(items), 10)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, list(range(10)))
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 2, 4, 5, 6, 8]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =4, sequence len =4, full features
seg_len = 4
idx4segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 4]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =3, sequence len =4, full feature
seg_len = 3
idx4segment = record.get_metadata4segment(segment_len=seg_len)
self.assertEqual(len(ids), 8)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 4, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
def test_idx4segment_brokenfeatures(self):
"""Test the idx4segment with some features from dataset missing."""
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 4])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
seg_len = 3
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["A100"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(items), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
seg_len = 3
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["A100"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["i5", "s1"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 1, 4, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["i5", "s1"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 3)
self.assertListEqual(ids, [0, 1, 2])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([2, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 0)
def build_simple_dataset():
"""Generate a fake dataset to test methods of Record.
Returns:
_type_: _description_
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_broken_dataset(feature_is_none_list: List[int]):
"""Generate a fake dataset to test methods of SeqRecord where some features does not exist.
Params:
feature_is_none_list (List[str]): indices of data-frame that have missing features
Returns:
None
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
if feature != "A100" or (i not in feature_is_none_list):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
else:
dataset[i][feature] = np.array(None)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_seq_dataset():
"""Generate an aritificial dataset to test methods of SeqRecord, w"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
for i in range(seq_len):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
if __name__ == "__main__":
np.random.seed(0)
unittest.main()
| seqrecord/robot/tests/test_seqrecord.py | microsoft-seqrecord-55c8d91 | [
{
"filename": "seqrecord/robot/example/record_dataset.py",
"retrieved_chunk": " )\n for _ in tqdm(range(num_seq)):\n for j in range(seq_len):\n item = {\n \"image_left\": np.random.rand(224, 224, 3),\n \"image_right\": np.random.rand(224, 224, 3),\n }\n record.write_item(item, (j == 0))\n record.close_recordfile()\n record.dump()",
"score": 37.20419805072512
},
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " wseqrecord.MAX_RECORDFILE_SIZE = file_size\n # encode dataset\n record.put_frame(frame_generator=iter(dataset))\n record.dump_record()\n # loaded_record = WSeqRecord.load_record_from_dict(\"./output/wseqrecord_test/\")\n # decode dataset\n for i, item in enumerate(record.iterate_frames(features=features)):\n for feature in features:\n nptest.assert_equal(\n item[feature], dataset[i][feature], err_msg=\"\", verbose=True",
"score": 36.78736020029722
},
{
"filename": "seqrecord/weather/test/test_wseqrecord.py",
"retrieved_chunk": " # loaded_record = WSeqRecord.load_record_from_dict(\"./output/wseqrecord_test/\")\n # decode dataset\n for i, item in enumerate(record.iterate_frames(features=features)):\n for feature in features:\n nptest.assert_equal(\n item[feature], dataset[i][feature], err_msg=\"\", verbose=True\n )\ndef test_read_framepairs_from_file(file_size: int, max_pred_steps: int):\n assert max_pred_steps > 1, \"maximum prediction steps need to be greater than 1\"\n dataset, record, features = build_weather_dataset()",
"score": 32.93530782415526
},
{
"filename": "seqrecord/weather/test/test_wseqrecord_mp.py",
"retrieved_chunk": " read_args = {\n \"input_features\": features[:random_partition],\n \"target_features\": features[random_partition:],\n \"max_pred_steps\": max_pred_steps,\n }\n record.add_read_args(read_args)\n fileidx_generator = ((record, i) for i in range(record.num_files))\n # read frame pairs\n for i, item in enumerate(\n record.iterate_framepairs_from_files(fileidx_generator)",
"score": 28.837226845750795
},
{
"filename": "seqrecord/robot/seqrecord.py",
"retrieved_chunk": " )\n frame[feature] = array1d.reshape(metadata_frame[feature][\"shape\"])\n return frame\n def read_frames(\n self, features: List[str]\n ) -> Generator[Dict[str, np.ndarray], None, None]:\n \"\"\"Given that the dataset has been recored, decode the record sequentially, each time\n returning a dict that contains the data item.\n Args:\n features [List[str]]: a list of features requested to read from item",
"score": 28.77965325419018
}
] | python | read_frames(features=features)): |
"""Unit test for seqrecord's functionalities"""
import unittest
from typing import Dict, List
import numpy as np
import numpy.testing as nptest
from seqrecord.robot.seqrecord import RSeqRecord
def concate_list(file2segment_item: Dict[str, list]):
res = []
for key in sorted(file2segment_item):
res = res + file2segment_item[key]
return res
class Test_RSeqRecord(unittest.TestCase):
def test_encode_decode(self):
"""Testing encode and decode of items, no segment involved."""
record, dataset, features = build_simple_dataset()
# encode dataset
for i, item in enumerate(dataset):
if i % 4 == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
record.dump()
# decode dataset
for i, item in enumerate(record.read_frames(features=features)):
for feature in features:
nptest.assert_equal(
item[feature], dataset[i][feature], err_msg="", verbose=True
)
loaded_record = RSeqRecord.load_record_from_dict("./output/seqrecord_test/")
def test_idx4segment(self):
"""Having the record written (and various attributes setup), generate an index protocal for
specific segment len."""
record, dataset, features = build_simple_dataset()
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
# segment len =2, sequence len =4, full features
seg_len = 2
idx4segment = record. | get_metadata4segment(segment_len=seg_len) |
items = concate_list(idx4segment["file2segment_items"])
self.assertEqual(len(items), 10)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, list(range(10)))
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 2, 4, 5, 6, 8]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =4, sequence len =4, full features
seg_len = 4
idx4segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 4]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =3, sequence len =4, full feature
seg_len = 3
idx4segment = record.get_metadata4segment(segment_len=seg_len)
self.assertEqual(len(ids), 8)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 4, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
def test_idx4segment_brokenfeatures(self):
"""Test the idx4segment with some features from dataset missing."""
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 4])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
seg_len = 3
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["A100"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(items), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
seg_len = 3
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["A100"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["i5", "s1"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 1, 4, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["i5", "s1"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 3)
self.assertListEqual(ids, [0, 1, 2])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([2, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 0)
def build_simple_dataset():
"""Generate a fake dataset to test methods of Record.
Returns:
_type_: _description_
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_broken_dataset(feature_is_none_list: List[int]):
"""Generate a fake dataset to test methods of SeqRecord where some features does not exist.
Params:
feature_is_none_list (List[str]): indices of data-frame that have missing features
Returns:
None
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
if feature != "A100" or (i not in feature_is_none_list):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
else:
dataset[i][feature] = np.array(None)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_seq_dataset():
"""Generate an aritificial dataset to test methods of SeqRecord, w"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
for i in range(seq_len):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
if __name__ == "__main__":
np.random.seed(0)
unittest.main()
| seqrecord/robot/tests/test_seqrecord.py | microsoft-seqrecord-55c8d91 | [
{
"filename": "seqrecord/robot/example/record_dataset.py",
"retrieved_chunk": " )\n for _ in tqdm(range(num_seq)):\n for j in range(seq_len):\n item = {\n \"image_left\": np.random.rand(224, 224, 3),\n \"image_right\": np.random.rand(224, 224, 3),\n }\n record.write_item(item, (j == 0))\n record.close_recordfile()\n record.dump()",
"score": 34.09050008977419
},
{
"filename": "seqrecord/robot/seqrecord.py",
"retrieved_chunk": " # a valid start of sequence\n q.append(idx)\n else:\n q.append(idx)\n if len(q) == segment_len:\n # claim: elements in the queue must be from the same sequence\n update_segmentproto(q.popleft(), is_segment_start=True)\n q_has_seg_tail = True\n if q and q_has_seg_tail:\n # front element in queue is need as last element of some segment",
"score": 31.552689254855775
},
{
"filename": "seqrecord/weather/test/test_wseqrecord_dist.py",
"retrieved_chunk": " item[feature], dataset[i][feature], err_msg=\"\", verbose=True\n )\n def test_read_frame_pair(self):\n print(\"Test read frame pairs\")\n num_nodes, num_processes = 3, 4\n record, dataset, rootdir, features = distributed_write(num_nodes, num_processes)\n max_pred_steps = 100\n random_partition = random.randint(1, len(features) - 2)\n input_features = features[:random_partition]\n output_features = features[random_partition:]",
"score": 26.297614067711905
},
{
"filename": "seqrecord/weather/test/test_wseqrecord_dist.py",
"retrieved_chunk": " verbose=True,\n )\n def test_fetch_frame_pair(self):\n print(\"Test fetch frame pairs\")\n num_nodes, num_processes = 2, 4\n record, dataset, rootdir, features = distributed_write(num_nodes, num_processes)\n max_pred_steps = 100\n random_partition = random.randint(1, len(features) - 2)\n input_features = features[:random_partition]\n output_features = features[random_partition:]",
"score": 25.135398015685833
},
{
"filename": "seqrecord/robot/seqrecord.py",
"retrieved_chunk": " item = self.read_frame(f, self.metadata[idx], features)\n yield {feature: item[feature] for feature in features}\n def get_metadata4segment(\n self, segment_len: int, sub_features: Optional[List[str]] = None\n ) -> Dict[str, Any]:\n \"\"\"Generate a protocal for reading segments from records. Each data item of segment should\n contain all features in sub_features.\n Note:\n Only call this function when record has scanned all data in dataset, and record has valid attributes: rootdir, recordfile_idx\n Args:",
"score": 23.355272468909845
}
] | python | get_metadata4segment(segment_len=seg_len) |
from unittest.mock import call
import pytest
from llm_client.llm_client.local_client import LocalClient, LocalClientConfig
@pytest.mark.asyncio
async def test_text_completion__sanity(local_client, mock_model, mock_tokenizer, tensors_type, device):
mock_tokenizer.encode.return_value.to.return_value = [1, 2, 3]
mock_model.generate.return_value = [1]
mock_tokenizer.decode.return_value = "first completion"
actual = await local_client.text_completion(prompt="These are a few of my favorite")
assert actual == ["first completion"]
mock_tokenizer.encode.assert_called_once_with("These are a few of my favorite", return_tensors=tensors_type)
mock_tokenizer.encode.return_value.to.assert_called_once_with(device)
mock_model.generate.assert_called_once_with([1, 2, 3])
mock_tokenizer.decode.assert_called_once_with(1)
@pytest.mark.asyncio
async def test_text_completion__return_multiple_completions(local_client, mock_model, mock_tokenizer, tensors_type,
device):
mock_tokenizer.encode.return_value.to.return_value = [1, 2, 3]
mock_model.generate.return_value = [2, 3, 4]
mock_tokenizer.decode.side_effect = ["first completion", "second completion", "third completion"]
actual = await local_client.text_completion(prompt="These are a few of my favorite")
assert actual == ["first completion", "second completion", "third completion"]
mock_tokenizer.encode.assert_called_once_with("These are a few of my favorite", return_tensors=tensors_type)
mock_tokenizer.encode.return_value.to.assert_called_once_with(device)
mock_model.generate.assert_called_once_with([1, 2, 3])
assert mock_tokenizer.decode.call_args_list == [call(2), call(3), call(4)]
@pytest.mark.asyncio
async def test_text_completion__with_kwargs(local_client, mock_model, mock_tokenizer, tensors_type, device):
mock_tokenizer.encode.return_value.to.return_value = [1, 2, 3]
mock_model.generate.return_value = [1]
mock_tokenizer.decode.return_value = "first completion"
actual = await local_client.text_completion(prompt="These are a few of my favorite", max_length=100)
assert actual == ["first completion"]
mock_tokenizer.encode.assert_called_once_with("These are a few of my favorite", return_tensors=tensors_type)
mock_tokenizer.encode.return_value.to.assert_called_once_with(device)
mock_model.generate.assert_called_once_with([1, 2, 3], max_length=100)
mock_tokenizer.decode.assert_called_once_with(1)
@pytest.mark.asyncio
async def test_text_completion__with_encode_kwargs(mock_model, mock_tokenizer, tensors_type, device):
mock_tokenizer.encode.return_value.to.return_value = [1, 2, 3]
mock_model.generate.return_value = [1]
mock_tokenizer.decode.return_value = "first completion"
encode_kwargs = {"add_special_tokens": False}
local_client = LocalClient(LocalClientConfig(mock_model, mock_tokenizer, tensors_type, device, encode_kwargs))
actual = await local_client.text_completion(prompt="These are a few of my favorite")
assert actual == ["first completion"]
mock_tokenizer.encode.assert_called_once_with("These are a few of my favorite", return_tensors=tensors_type,
add_special_tokens=False)
mock_tokenizer.encode.return_value.to.assert_called_once_with(device)
mock_model.generate.assert_called_once_with([1, 2, 3])
mock_tokenizer.decode.assert_called_once_with(1)
@pytest.mark.asyncio
async def test_get_tokens_count__sanity(local_client, mock_tokenizer, tensors_type, device):
mock_tokenizer.encode.return_value.to.return_value = [1, 2, 3]
actual = await local_client.get_tokens_count(text="This is a test")
assert actual == 3
mock_tokenizer.encode.assert_called_once_with("This is a test", return_tensors=tensors_type)
mock_tokenizer.encode.return_value.to.assert_called_once_with(device)
@pytest.mark.asyncio
async def test_get_tokens_count__with_kwargs(mock_model, mock_tokenizer, tensors_type, device):
mock_tokenizer.encode.return_value.to.return_value = [1, 2, 3]
encode_kwargs = {"add_special_tokens": False}
local_client = LocalClient(LocalClientConfig(mock_model, mock_tokenizer, tensors_type, device, encode_kwargs))
actual = await local_client. | get_tokens_count(text="This is a test") |
assert actual == 3
mock_tokenizer.encode.assert_called_once_with("This is a test", return_tensors=tensors_type,
add_special_tokens=False)
mock_tokenizer.encode.return_value.to.assert_called_once_with(device)
| tests/llm_client/local_client/test_local_client.py | uripeled2-llm-client-sdk-66af541 | [
{
"filename": "tests/llm_client/local_client/conftest.py",
"retrieved_chunk": "@pytest.fixture\ndef tensors_type():\n return \"pt\"\[email protected]\ndef device():\n return \"cpu\"\[email protected]\ndef local_client(mock_model, mock_tokenizer, tensors_type, device):\n return LocalClient(LocalClientConfig(mock_model, mock_tokenizer, tensors_type, device))",
"score": 107.57639511506785
},
{
"filename": "tests/llm_api_client/openai_client/test_openai.py",
"retrieved_chunk": " tokeniser_mock = tiktoken_mock.encoding_for_model.return_value\n tokeniser_mock.encode.return_value = [123, 456]\n text = \"This is a test\"\n model_name = \"gpt3\"\n actual = await open_ai_client.get_tokens_count(text=text, model=model_name)\n assert actual == len(tokeniser_mock.encode.return_value)\n tiktoken_mock.encoding_for_model.assert_called_once_with(model_name)\n tokeniser_mock.encode.assert_called_once_with(text)",
"score": 55.88539461731427
},
{
"filename": "tests/llm_api_client/openai_client/test_openai.py",
"retrieved_chunk": "async def test_get_tokens_count__sanity(model_name, open_ai_client, tiktoken_mock):\n tokeniser_mock = tiktoken_mock.encoding_for_model.return_value\n tokeniser_mock.encode.return_value = [123, 456]\n text = \"This is a test\"\n actual = await open_ai_client.get_tokens_count(text=text)\n assert actual == len(tokeniser_mock.encode.return_value)\n tiktoken_mock.encoding_for_model.assert_called_once_with(model_name)\n tokeniser_mock.encode.assert_called_once_with(text)\[email protected]\nasync def test_get_tokens_count__override_model(open_ai_client, tiktoken_mock):",
"score": 54.987897429044914
},
{
"filename": "tests/llm_client/local_client/conftest.py",
"retrieved_chunk": "from unittest.mock import MagicMock\nimport pytest\nfrom transformers import PreTrainedTokenizerBase\nfrom llm_client import LocalClientConfig, LocalClient\[email protected]\ndef mock_model():\n return MagicMock()\[email protected]\ndef mock_tokenizer():\n return MagicMock(PreTrainedTokenizerBase)",
"score": 43.41645242517631
},
{
"filename": "llm_client/llm_client/local_client.py",
"retrieved_chunk": " model: PreTrainedModel\n tokenizer: PreTrainedTokenizerBase\n tensors_type: str\n device: str\n encode_kwargs: dict[str, Any] = field(default_factory=dict)\nclass LocalClient(BaseLLMClient):\n def __init__(self, llm_client_config: LocalClientConfig):\n if not llm_client_config.model.can_generate():\n raise TypeError(f\"{llm_client_config.model} is not a text generation model\")\n self._model: PreTrainedModel = llm_client_config.model",
"score": 42.814557640051135
}
] | python | get_tokens_count(text="This is a test") |
from functools import lru_cache
from typing import Optional
import openai
import tiktoken
from tiktoken import Encoding
from llm_client.llm_api_client.base_llm_api_client import BaseLLMAPIClient, LLMAPIClientConfig, ChatMessage
from llm_client.consts import PROMPT_KEY
INPUT_KEY = "input"
MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME = {
"gpt-3.5-turbo-0613": (3, 1),
"gpt-3.5-turbo-16k-0613": (3, 1),
"gpt-4-0314": (3, 1),
"gpt-4-32k-0314": (3, 1),
"gpt-4-0613": (3, 1),
"gpt-4-32k-0613": (3, 1),
# every message follows <|start|>{role/name}\n{content}<|end|>\n, if there's a name, the role is omitted
"gpt-3.5-turbo-0301": (4, -1),
}
class OpenAIClient(BaseLLMAPIClient):
def __init__(self, config: LLMAPIClientConfig):
super().__init__(config)
openai.api_key = self._api_key
openai.aiosession.set(self._session)
self._client = openai
async def text_completion(self, prompt: str, model: Optional[str] = None, temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, **kwargs) -> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs[PROMPT_KEY] = prompt
kwargs["top_p"] = top_p
kwargs["temperature"] = temperature
kwargs["max_tokens"] = max_tokens
completions = await self._client.Completion.acreate(headers=self. | _headers, **kwargs) |
return [choice.text for choice in completions.choices]
async def chat_completion(self, messages: list[ChatMessage], temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, model: Optional[str] = None, **kwargs) \
-> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs["messages"] = [message.to_dict() for message in messages]
kwargs["temperature"] = temperature
kwargs["top_p"] = top_p
kwargs["max_tokens"] = max_tokens
completions = await self._client.ChatCompletion.acreate(headers=self._headers, **kwargs)
return [choice.message.content for choice in completions.choices]
async def embedding(self, text: str, model: Optional[str] = None, **kwargs) -> list[float]:
self._set_model_in_kwargs(kwargs, model)
kwargs[INPUT_KEY] = text
embeddings = await openai.Embedding.acreate(**kwargs)
return embeddings.data[0].embedding
async def get_tokens_count(self, text: str, model: Optional[str] = None, **kwargs) -> int:
if model is None:
model = self._default_model
return len(self._get_relevant_tokeniser(model).encode(text))
async def get_chat_tokens_count(self, messages: list[ChatMessage], model: Optional[str] = None) -> int:
"""
This is based on:
https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
"""
model = self._get_model_name_for_tokeniser(model)
encoding = self._get_relevant_tokeniser(model)
tokens_per_message, tokens_per_name = MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME[model]
num_tokens = 0
for message in messages:
num_tokens += tokens_per_message
num_tokens += len(encoding.encode(message.content))
num_tokens += len(encoding.encode(message.role.value))
if message.name:
num_tokens += len(encoding.encode(message.name))
num_tokens += tokens_per_name
num_tokens += 3 # every reply is primed with <|start|>assistant<|message|>
return num_tokens
def _get_model_name_for_tokeniser(self, model: Optional[str] = None) -> str:
if model is None:
model = self._default_model
if model in {
"gpt-3.5-turbo-0613",
"gpt-3.5-turbo-16k-0613",
"gpt-4-0314",
"gpt-4-32k-0314",
"gpt-4-0613",
"gpt-4-32k-0613",
}:
return model
elif model == "gpt-3.5-turbo-0301":
return model
elif "gpt-3.5-turbo" in model:
print("Warning: gpt-3.5-turbo may update over time. Returning tokeniser assuming gpt-3.5-turbo-0613.")
return "gpt-3.5-turbo-0613"
elif "gpt-4" in model:
print("Warning: gpt-4 may update over time. Returning tokeniser assuming gpt-4-0613.")
return "gpt-4-0613"
else:
raise NotImplementedError(
f"""not implemented for model {model}.
See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
)
@staticmethod
@lru_cache(maxsize=40)
def _get_relevant_tokeniser(model: str) -> Encoding:
return tiktoken.encoding_for_model(model)
| llm_client/llm_api_client/openai_client.py | uripeled2-llm-client-sdk-66af541 | [
{
"filename": "llm_client/llm_api_client/anthropic_client.py",
"retrieved_chunk": " async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: Optional[int] = None,\n temperature: float = 1, top_p: Optional[float] = None,\n **kwargs) -> \\\n list[str]:\n if max_tokens is None and kwargs.get(MAX_TOKENS_KEY) is None:\n raise ValueError(f\"max_tokens or {MAX_TOKENS_KEY} must be specified\")\n if top_p:\n kwargs[\"top_p\"] = top_p\n self._set_model_in_kwargs(kwargs, model)\n kwargs[PROMPT_KEY] = prompt",
"score": 78.58461182164184
},
{
"filename": "llm_client/llm_api_client/huggingface_client.py",
"retrieved_chunk": " self._base_url = BASE_URL\n if self._default_model is None:\n self._default_model = DEFAULT_MODEL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, max_tokens: Optional[int] = None, temperature: float = 1.0,\n model: Optional[str] = None, top_p: Optional[float] = None, **kwargs) -> list[str]:\n model = model or self._default_model\n kwargs[\"top_p\"] = top_p\n kwargs[INPUT_KEY] = prompt\n kwargs[TEMPERATURE_KEY] = temperature",
"score": 77.58756501668599
},
{
"filename": "llm_client/llm_api_client/aleph_alpha_client.py",
"retrieved_chunk": " if self._base_url is None:\n self._base_url = BASE_URL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: Optional[int] = None,\n temperature: float = 0,top_p: float = 0, **kwargs) -> \\\n list[str]:\n self._set_model_in_kwargs(kwargs, model)\n if max_tokens is None:\n raise ValueError(\"max_tokens must be specified\")\n kwargs[PROMPT_KEY] = prompt",
"score": 77.24701870436805
},
{
"filename": "llm_client/llm_api_client/base_llm_api_client.py",
"retrieved_chunk": " async def chat_completion(self, messages: list[ChatMessage], temperature: float = 0,\n max_tokens: int = 16, model: Optional[str] = None, **kwargs) -> list[str]:\n raise NotImplementedError()\n async def embedding(self, text: str, model: Optional[str] = None, **kwargs) -> list[float]:\n raise NotImplementedError()\n async def get_chat_tokens_count(self, messages: list[ChatMessage], **kwargs) -> int:\n raise NotImplementedError()\n def _set_model_in_kwargs(self, kwargs, model: Optional[str]) -> None:\n if model is not None:\n kwargs[MODEL_KEY] = model",
"score": 69.5788349105527
},
{
"filename": "llm_client/llm_api_client/ai21_client.py",
"retrieved_chunk": "AUTH_HEADER = \"Authorization\"\nBEARER_TOKEN = \"Bearer \"\nclass AI21Client(BaseLLMAPIClient):\n def __init__(self, config: LLMAPIClientConfig):\n super().__init__(config)\n if self._base_url is None:\n self._base_url = BASE_URL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: int = 16,\n temperature: float = 0.7, top_p: float = 1,**kwargs) -> list[str]:",
"score": 64.40513348752197
}
] | python | _headers, **kwargs) |
from functools import lru_cache
from typing import Optional
import openai
import tiktoken
from tiktoken import Encoding
from llm_client.llm_api_client.base_llm_api_client import BaseLLMAPIClient, LLMAPIClientConfig, ChatMessage
from llm_client.consts import PROMPT_KEY
INPUT_KEY = "input"
MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME = {
"gpt-3.5-turbo-0613": (3, 1),
"gpt-3.5-turbo-16k-0613": (3, 1),
"gpt-4-0314": (3, 1),
"gpt-4-32k-0314": (3, 1),
"gpt-4-0613": (3, 1),
"gpt-4-32k-0613": (3, 1),
# every message follows <|start|>{role/name}\n{content}<|end|>\n, if there's a name, the role is omitted
"gpt-3.5-turbo-0301": (4, -1),
}
class OpenAIClient(BaseLLMAPIClient):
def __init__(self, config: LLMAPIClientConfig):
super().__init__(config)
openai.api_key = self._api_key
openai.aiosession.set(self._session)
self._client = openai
async def text_completion(self, prompt: str, model: Optional[str] = None, temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, **kwargs) -> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs[PROMPT_KEY] = prompt
kwargs["top_p"] = top_p
kwargs["temperature"] = temperature
kwargs["max_tokens"] = max_tokens
completions = await self._client. | Completion.acreate(headers=self._headers, **kwargs) |
return [choice.text for choice in completions.choices]
async def chat_completion(self, messages: list[ChatMessage], temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, model: Optional[str] = None, **kwargs) \
-> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs["messages"] = [message.to_dict() for message in messages]
kwargs["temperature"] = temperature
kwargs["top_p"] = top_p
kwargs["max_tokens"] = max_tokens
completions = await self._client.ChatCompletion.acreate(headers=self._headers, **kwargs)
return [choice.message.content for choice in completions.choices]
async def embedding(self, text: str, model: Optional[str] = None, **kwargs) -> list[float]:
self._set_model_in_kwargs(kwargs, model)
kwargs[INPUT_KEY] = text
embeddings = await openai.Embedding.acreate(**kwargs)
return embeddings.data[0].embedding
async def get_tokens_count(self, text: str, model: Optional[str] = None, **kwargs) -> int:
if model is None:
model = self._default_model
return len(self._get_relevant_tokeniser(model).encode(text))
async def get_chat_tokens_count(self, messages: list[ChatMessage], model: Optional[str] = None) -> int:
"""
This is based on:
https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
"""
model = self._get_model_name_for_tokeniser(model)
encoding = self._get_relevant_tokeniser(model)
tokens_per_message, tokens_per_name = MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME[model]
num_tokens = 0
for message in messages:
num_tokens += tokens_per_message
num_tokens += len(encoding.encode(message.content))
num_tokens += len(encoding.encode(message.role.value))
if message.name:
num_tokens += len(encoding.encode(message.name))
num_tokens += tokens_per_name
num_tokens += 3 # every reply is primed with <|start|>assistant<|message|>
return num_tokens
def _get_model_name_for_tokeniser(self, model: Optional[str] = None) -> str:
if model is None:
model = self._default_model
if model in {
"gpt-3.5-turbo-0613",
"gpt-3.5-turbo-16k-0613",
"gpt-4-0314",
"gpt-4-32k-0314",
"gpt-4-0613",
"gpt-4-32k-0613",
}:
return model
elif model == "gpt-3.5-turbo-0301":
return model
elif "gpt-3.5-turbo" in model:
print("Warning: gpt-3.5-turbo may update over time. Returning tokeniser assuming gpt-3.5-turbo-0613.")
return "gpt-3.5-turbo-0613"
elif "gpt-4" in model:
print("Warning: gpt-4 may update over time. Returning tokeniser assuming gpt-4-0613.")
return "gpt-4-0613"
else:
raise NotImplementedError(
f"""not implemented for model {model}.
See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
)
@staticmethod
@lru_cache(maxsize=40)
def _get_relevant_tokeniser(model: str) -> Encoding:
return tiktoken.encoding_for_model(model)
| llm_client/llm_api_client/openai_client.py | uripeled2-llm-client-sdk-66af541 | [
{
"filename": "llm_client/llm_api_client/anthropic_client.py",
"retrieved_chunk": " async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: Optional[int] = None,\n temperature: float = 1, top_p: Optional[float] = None,\n **kwargs) -> \\\n list[str]:\n if max_tokens is None and kwargs.get(MAX_TOKENS_KEY) is None:\n raise ValueError(f\"max_tokens or {MAX_TOKENS_KEY} must be specified\")\n if top_p:\n kwargs[\"top_p\"] = top_p\n self._set_model_in_kwargs(kwargs, model)\n kwargs[PROMPT_KEY] = prompt",
"score": 78.58461182164184
},
{
"filename": "llm_client/llm_api_client/huggingface_client.py",
"retrieved_chunk": " self._base_url = BASE_URL\n if self._default_model is None:\n self._default_model = DEFAULT_MODEL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, max_tokens: Optional[int] = None, temperature: float = 1.0,\n model: Optional[str] = None, top_p: Optional[float] = None, **kwargs) -> list[str]:\n model = model or self._default_model\n kwargs[\"top_p\"] = top_p\n kwargs[INPUT_KEY] = prompt\n kwargs[TEMPERATURE_KEY] = temperature",
"score": 77.58756501668599
},
{
"filename": "llm_client/llm_api_client/aleph_alpha_client.py",
"retrieved_chunk": " if self._base_url is None:\n self._base_url = BASE_URL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: Optional[int] = None,\n temperature: float = 0,top_p: float = 0, **kwargs) -> \\\n list[str]:\n self._set_model_in_kwargs(kwargs, model)\n if max_tokens is None:\n raise ValueError(\"max_tokens must be specified\")\n kwargs[PROMPT_KEY] = prompt",
"score": 77.24701870436805
},
{
"filename": "llm_client/llm_api_client/base_llm_api_client.py",
"retrieved_chunk": " async def chat_completion(self, messages: list[ChatMessage], temperature: float = 0,\n max_tokens: int = 16, model: Optional[str] = None, **kwargs) -> list[str]:\n raise NotImplementedError()\n async def embedding(self, text: str, model: Optional[str] = None, **kwargs) -> list[float]:\n raise NotImplementedError()\n async def get_chat_tokens_count(self, messages: list[ChatMessage], **kwargs) -> int:\n raise NotImplementedError()\n def _set_model_in_kwargs(self, kwargs, model: Optional[str]) -> None:\n if model is not None:\n kwargs[MODEL_KEY] = model",
"score": 69.5788349105527
},
{
"filename": "llm_client/llm_api_client/ai21_client.py",
"retrieved_chunk": "AUTH_HEADER = \"Authorization\"\nBEARER_TOKEN = \"Bearer \"\nclass AI21Client(BaseLLMAPIClient):\n def __init__(self, config: LLMAPIClientConfig):\n super().__init__(config)\n if self._base_url is None:\n self._base_url = BASE_URL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: int = 16,\n temperature: float = 0.7, top_p: float = 1,**kwargs) -> list[str]:",
"score": 64.40513348752197
}
] | python | Completion.acreate(headers=self._headers, **kwargs) |
from functools import lru_cache
from typing import Optional
import openai
import tiktoken
from tiktoken import Encoding
from llm_client.llm_api_client.base_llm_api_client import BaseLLMAPIClient, LLMAPIClientConfig, ChatMessage
from llm_client.consts import PROMPT_KEY
INPUT_KEY = "input"
MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME = {
"gpt-3.5-turbo-0613": (3, 1),
"gpt-3.5-turbo-16k-0613": (3, 1),
"gpt-4-0314": (3, 1),
"gpt-4-32k-0314": (3, 1),
"gpt-4-0613": (3, 1),
"gpt-4-32k-0613": (3, 1),
# every message follows <|start|>{role/name}\n{content}<|end|>\n, if there's a name, the role is omitted
"gpt-3.5-turbo-0301": (4, -1),
}
class OpenAIClient(BaseLLMAPIClient):
def __init__(self, config: LLMAPIClientConfig):
super().__init__(config)
openai.api_key = self._api_key
openai.aiosession.set(self._session)
self._client = openai
async def text_completion(self, prompt: str, model: Optional[str] = None, temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, **kwargs) -> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs[PROMPT_KEY] = prompt
kwargs["top_p"] = top_p
kwargs["temperature"] = temperature
kwargs["max_tokens"] = max_tokens
completions = await self._client.Completion.acreate(headers=self._headers, **kwargs)
return [choice.text for choice in completions.choices]
async def chat_completion(self, messages: list[ChatMessage], temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, model: Optional[str] = None, **kwargs) \
-> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs["messages"] = [message.to_dict() for message in messages]
kwargs["temperature"] = temperature
kwargs["top_p"] = top_p
kwargs["max_tokens"] = max_tokens
completions = await self._client.ChatCompletion.acreate(headers=self._headers, **kwargs)
return [choice.message.content for choice in completions.choices]
async def embedding(self, text: str, model: Optional[str] = None, **kwargs) -> list[float]:
self._set_model_in_kwargs(kwargs, model)
kwargs[INPUT_KEY] = text
embeddings = await openai. | Embedding.acreate(**kwargs) |
return embeddings.data[0].embedding
async def get_tokens_count(self, text: str, model: Optional[str] = None, **kwargs) -> int:
if model is None:
model = self._default_model
return len(self._get_relevant_tokeniser(model).encode(text))
async def get_chat_tokens_count(self, messages: list[ChatMessage], model: Optional[str] = None) -> int:
"""
This is based on:
https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
"""
model = self._get_model_name_for_tokeniser(model)
encoding = self._get_relevant_tokeniser(model)
tokens_per_message, tokens_per_name = MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME[model]
num_tokens = 0
for message in messages:
num_tokens += tokens_per_message
num_tokens += len(encoding.encode(message.content))
num_tokens += len(encoding.encode(message.role.value))
if message.name:
num_tokens += len(encoding.encode(message.name))
num_tokens += tokens_per_name
num_tokens += 3 # every reply is primed with <|start|>assistant<|message|>
return num_tokens
def _get_model_name_for_tokeniser(self, model: Optional[str] = None) -> str:
if model is None:
model = self._default_model
if model in {
"gpt-3.5-turbo-0613",
"gpt-3.5-turbo-16k-0613",
"gpt-4-0314",
"gpt-4-32k-0314",
"gpt-4-0613",
"gpt-4-32k-0613",
}:
return model
elif model == "gpt-3.5-turbo-0301":
return model
elif "gpt-3.5-turbo" in model:
print("Warning: gpt-3.5-turbo may update over time. Returning tokeniser assuming gpt-3.5-turbo-0613.")
return "gpt-3.5-turbo-0613"
elif "gpt-4" in model:
print("Warning: gpt-4 may update over time. Returning tokeniser assuming gpt-4-0613.")
return "gpt-4-0613"
else:
raise NotImplementedError(
f"""not implemented for model {model}.
See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
)
@staticmethod
@lru_cache(maxsize=40)
def _get_relevant_tokeniser(model: str) -> Encoding:
return tiktoken.encoding_for_model(model)
| llm_client/llm_api_client/openai_client.py | uripeled2-llm-client-sdk-66af541 | [
{
"filename": "llm_client/llm_api_client/huggingface_client.py",
"retrieved_chunk": " self._base_url = BASE_URL\n if self._default_model is None:\n self._default_model = DEFAULT_MODEL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, max_tokens: Optional[int] = None, temperature: float = 1.0,\n model: Optional[str] = None, top_p: Optional[float] = None, **kwargs) -> list[str]:\n model = model or self._default_model\n kwargs[\"top_p\"] = top_p\n kwargs[INPUT_KEY] = prompt\n kwargs[TEMPERATURE_KEY] = temperature",
"score": 63.43553636018117
},
{
"filename": "llm_client/llm_api_client/aleph_alpha_client.py",
"retrieved_chunk": " async def embedding(self, text: str, model: Optional[str] = None,\n representation: str = REPRESENTATION_DEFAULT_VALUE,\n **kwargs) -> list[float]:\n self._set_model_in_kwargs(kwargs, model)\n kwargs[REPRESENTATION_KEY] = representation\n kwargs[PROMPT_KEY] = text\n response = await self._session.post(self._base_url + EMBEDDING_PATH,\n json=kwargs,\n headers=self._headers,\n raise_for_status=True)",
"score": 61.47978007593138
},
{
"filename": "llm_client/llm_api_client/base_llm_api_client.py",
"retrieved_chunk": " async def chat_completion(self, messages: list[ChatMessage], temperature: float = 0,\n max_tokens: int = 16, model: Optional[str] = None, **kwargs) -> list[str]:\n raise NotImplementedError()\n async def embedding(self, text: str, model: Optional[str] = None, **kwargs) -> list[float]:\n raise NotImplementedError()\n async def get_chat_tokens_count(self, messages: list[ChatMessage], **kwargs) -> int:\n raise NotImplementedError()\n def _set_model_in_kwargs(self, kwargs, model: Optional[str]) -> None:\n if model is not None:\n kwargs[MODEL_KEY] = model",
"score": 61.21897297549248
},
{
"filename": "llm_client/llm_api_client/anthropic_client.py",
"retrieved_chunk": " async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: Optional[int] = None,\n temperature: float = 1, top_p: Optional[float] = None,\n **kwargs) -> \\\n list[str]:\n if max_tokens is None and kwargs.get(MAX_TOKENS_KEY) is None:\n raise ValueError(f\"max_tokens or {MAX_TOKENS_KEY} must be specified\")\n if top_p:\n kwargs[\"top_p\"] = top_p\n self._set_model_in_kwargs(kwargs, model)\n kwargs[PROMPT_KEY] = prompt",
"score": 60.76314705772446
},
{
"filename": "llm_client/llm_api_client/aleph_alpha_client.py",
"retrieved_chunk": " kwargs[\"top_p\"] = top_p\n kwargs[\"maximum_tokens\"] = kwargs.pop(\"maximum_tokens\", max_tokens)\n kwargs[\"temperature\"] = temperature\n response = await self._session.post(self._base_url + COMPLETE_PATH,\n json=kwargs,\n headers=self._headers,\n raise_for_status=True)\n response_json = await response.json()\n completions = response_json[COMPLETIONS_KEY]\n return [completion[TEXT_KEY] for completion in completions]",
"score": 59.205764912014864
}
] | python | Embedding.acreate(**kwargs) |
from functools import lru_cache
from typing import Optional
import openai
import tiktoken
from tiktoken import Encoding
from llm_client.llm_api_client.base_llm_api_client import BaseLLMAPIClient, LLMAPIClientConfig, ChatMessage
from llm_client.consts import PROMPT_KEY
INPUT_KEY = "input"
MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME = {
"gpt-3.5-turbo-0613": (3, 1),
"gpt-3.5-turbo-16k-0613": (3, 1),
"gpt-4-0314": (3, 1),
"gpt-4-32k-0314": (3, 1),
"gpt-4-0613": (3, 1),
"gpt-4-32k-0613": (3, 1),
# every message follows <|start|>{role/name}\n{content}<|end|>\n, if there's a name, the role is omitted
"gpt-3.5-turbo-0301": (4, -1),
}
class OpenAIClient(BaseLLMAPIClient):
def __init__(self, config: LLMAPIClientConfig):
super().__init__(config)
openai.api_key = self._api_key
openai. | aiosession.set(self._session) |
self._client = openai
async def text_completion(self, prompt: str, model: Optional[str] = None, temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, **kwargs) -> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs[PROMPT_KEY] = prompt
kwargs["top_p"] = top_p
kwargs["temperature"] = temperature
kwargs["max_tokens"] = max_tokens
completions = await self._client.Completion.acreate(headers=self._headers, **kwargs)
return [choice.text for choice in completions.choices]
async def chat_completion(self, messages: list[ChatMessage], temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, model: Optional[str] = None, **kwargs) \
-> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs["messages"] = [message.to_dict() for message in messages]
kwargs["temperature"] = temperature
kwargs["top_p"] = top_p
kwargs["max_tokens"] = max_tokens
completions = await self._client.ChatCompletion.acreate(headers=self._headers, **kwargs)
return [choice.message.content for choice in completions.choices]
async def embedding(self, text: str, model: Optional[str] = None, **kwargs) -> list[float]:
self._set_model_in_kwargs(kwargs, model)
kwargs[INPUT_KEY] = text
embeddings = await openai.Embedding.acreate(**kwargs)
return embeddings.data[0].embedding
async def get_tokens_count(self, text: str, model: Optional[str] = None, **kwargs) -> int:
if model is None:
model = self._default_model
return len(self._get_relevant_tokeniser(model).encode(text))
async def get_chat_tokens_count(self, messages: list[ChatMessage], model: Optional[str] = None) -> int:
"""
This is based on:
https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
"""
model = self._get_model_name_for_tokeniser(model)
encoding = self._get_relevant_tokeniser(model)
tokens_per_message, tokens_per_name = MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME[model]
num_tokens = 0
for message in messages:
num_tokens += tokens_per_message
num_tokens += len(encoding.encode(message.content))
num_tokens += len(encoding.encode(message.role.value))
if message.name:
num_tokens += len(encoding.encode(message.name))
num_tokens += tokens_per_name
num_tokens += 3 # every reply is primed with <|start|>assistant<|message|>
return num_tokens
def _get_model_name_for_tokeniser(self, model: Optional[str] = None) -> str:
if model is None:
model = self._default_model
if model in {
"gpt-3.5-turbo-0613",
"gpt-3.5-turbo-16k-0613",
"gpt-4-0314",
"gpt-4-32k-0314",
"gpt-4-0613",
"gpt-4-32k-0613",
}:
return model
elif model == "gpt-3.5-turbo-0301":
return model
elif "gpt-3.5-turbo" in model:
print("Warning: gpt-3.5-turbo may update over time. Returning tokeniser assuming gpt-3.5-turbo-0613.")
return "gpt-3.5-turbo-0613"
elif "gpt-4" in model:
print("Warning: gpt-4 may update over time. Returning tokeniser assuming gpt-4-0613.")
return "gpt-4-0613"
else:
raise NotImplementedError(
f"""not implemented for model {model}.
See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
)
@staticmethod
@lru_cache(maxsize=40)
def _get_relevant_tokeniser(model: str) -> Encoding:
return tiktoken.encoding_for_model(model)
| llm_client/llm_api_client/openai_client.py | uripeled2-llm-client-sdk-66af541 | [
{
"filename": "llm_client/llm_api_client/huggingface_client.py",
"retrieved_chunk": "DEFAULT_MODEL = \"oasst-sft-4-pythia-12b-epoch-3.5\"\nCONST_SLASH = '/'\nEMPTY_STR = ''\nNEWLINE = '\\n'\nTEMPERATURE_KEY = \"temperature\"\nTOKENS_KEY = \"max_length\"\nclass HuggingFaceClient(BaseLLMAPIClient):\n def __init__(self, config: LLMAPIClientConfig):\n super().__init__(config)\n if self._base_url is None:",
"score": 53.03192345401992
},
{
"filename": "tests/llm_api_client/openai_client/test_openai.py",
"retrieved_chunk": " open_ai_client = OpenAIClient(LLMAPIClientConfig(\"fake_api_key\", MagicMock(ClientSession), default_model=model_name,\n headers={\"header_name\": \"header_value\"}))\n actual = await open_ai_client.chat_completion([ChatMessage(Role.USER, \"Hello!\")])\n assert actual == [\"\\n\\nHello there, how may I assist you today?\"]\n openai_mock.ChatCompletion.acreate.assert_awaited_once_with(\n model=model_name,\n messages=[{'content': 'Hello!', 'role': 'user'}],\n headers={\"header_name\": \"header_value\"}, temperature=0, max_tokens=16, top_p=1)\[email protected]\[email protected](\"model_name,expected\", [(\"gpt-3.5-turbo-0301\", 127), (\"gpt-3.5-turbo-0613\", 129),",
"score": 47.290534103054384
},
{
"filename": "tests/llm_api_client/openai_client/test_openai.py",
"retrieved_chunk": " (\"gpt-3.5-turbo\", 129), (\"gpt-4-0314\", 129), (\"gpt-4-0613\", 129),\n (\"gpt-4\", 129)])\nasync def test_get_chat_tokens_count__with_examples_from_openai_cookbook(model_name, expected, open_ai_client):\n example_messages = [\n ChatMessage(Role.SYSTEM,\n \"You are a helpful, pattern-following assistant that translates corporate jargon \"\n \"into plain English.\"),\n ChatMessage(Role.SYSTEM, \"New synergies will help drive top-line growth.\", name=\"example_user\"),\n ChatMessage(Role.SYSTEM, \"Things working well together will increase revenue.\", name=\"example_assistant\"),\n ChatMessage(Role.SYSTEM,",
"score": 45.030647312382754
},
{
"filename": "llm_client/llm_api_client/anthropic_client.py",
"retrieved_chunk": "ACCEPT_VALUE = \"application/json\"\nMAX_TOKENS_KEY = \"max_tokens_to_sample\"\nUSER_PREFIX = \"Human:\"\nASSISTANT_PREFIX = \"Assistant:\"\nSTART_PREFIX = \"\\n\\n\"\nSYSTEM_START_PREFIX = \"<admin>\"\nSYSTEM_END_PREFIX = \"</admin>\"\nclass AnthropicClient(BaseLLMAPIClient):\n def __init__(self, config: LLMAPIClientConfig):\n super().__init__(config)",
"score": 35.69668108315261
},
{
"filename": "llm_client/llm_api_client/ai21_client.py",
"retrieved_chunk": "AUTH_HEADER = \"Authorization\"\nBEARER_TOKEN = \"Bearer \"\nclass AI21Client(BaseLLMAPIClient):\n def __init__(self, config: LLMAPIClientConfig):\n super().__init__(config)\n if self._base_url is None:\n self._base_url = BASE_URL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: int = 16,\n temperature: float = 0.7, top_p: float = 1,**kwargs) -> list[str]:",
"score": 33.5565114139562
}
] | python | aiosession.set(self._session) |
"""Unit test for seqrecord's functionalities"""
import unittest
from typing import Dict, List
import numpy as np
import numpy.testing as nptest
from seqrecord.robot.seqrecord import RSeqRecord
def concate_list(file2segment_item: Dict[str, list]):
res = []
for key in sorted(file2segment_item):
res = res + file2segment_item[key]
return res
class Test_RSeqRecord(unittest.TestCase):
def test_encode_decode(self):
"""Testing encode and decode of items, no segment involved."""
record, dataset, features = build_simple_dataset()
# encode dataset
for i, item in enumerate(dataset):
if i % 4 == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
record.dump()
# decode dataset
for i, item in enumerate(record.read_frames(features=features)):
for feature in features:
nptest.assert_equal(
item[feature], dataset[i][feature], err_msg="", verbose=True
)
loaded_record = RSeqRecord.load_record_from_dict("./output/seqrecord_test/")
def test_idx4segment(self):
"""Having the record written (and various attributes setup), generate an index protocal for
specific segment len."""
record, dataset, features = build_simple_dataset()
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
# segment len =2, sequence len =4, full features
seg_len = 2
idx4segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(idx4segment["file2segment_items"])
self.assertEqual(len(items), 10)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, list(range(10)))
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 2, 4, 5, 6, 8]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record. | read_segments(idx4segment)): |
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =4, sequence len =4, full features
seg_len = 4
idx4segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 4]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len =3, sequence len =4, full feature
seg_len = 3
idx4segment = record.get_metadata4segment(segment_len=seg_len)
self.assertEqual(len(ids), 8)
items = concate_list(idx4segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if i in [0, 1, 4, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = idx4segment["head4segment"]
for i, segment in enumerate(record.read_segments(idx4segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
def test_idx4segment_brokenfeatures(self):
"""Test the idx4segment with some features from dataset missing."""
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 4])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_segment_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_segment_start)
else:
self.assertFalse(is_segment_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
seg_len = 3
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["A100"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(items), 6)
self.assertListEqual(ids, [0, 1, 2, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
seg_len = 3
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["A100"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
metadata_segment = record.get_metadata4segment(
segment_len=seg_len, sub_features=["i5", "s1"]
)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 8)
self.assertListEqual(ids, [0, 1, 2, 3, 4, 5, 6, 7])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 1, 4, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in ["i5", "s1"]:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([3, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 3)
self.assertListEqual(ids, [0, 1, 2])
for i, (is_seg_start, item) in enumerate(items):
if item in [0, 5]:
self.assertTrue(is_seg_start)
else:
self.assertFalse(is_seg_start)
heads = metadata_segment["head4segment"]
for i, segment in enumerate(record.read_segments(metadata_segment)):
for j in range(seg_len):
for feature in features:
nptest.assert_equal(
dataset[heads[i] + j][feature],
segment[feature][j],
err_msg="",
verbose=True,
)
# segment len = 3, sequence len =4, break two features
record, dataset, features = build_broken_dataset([2, 6])
seq_len = 4
# encode dataset
for i, item in enumerate(dataset):
if i % seq_len == 0:
# mock start of a sequence
record.write_item(item, True)
else:
record.write_item(item, False)
record.close_recordfile()
seg_len = 3
metadata_segment = record.get_metadata4segment(segment_len=seg_len)
items = concate_list(metadata_segment["file2segment_items"])
ids = [item_idx for _, item_idx in items]
self.assertEqual(len(ids), 0)
def build_simple_dataset():
"""Generate a fake dataset to test methods of Record.
Returns:
_type_: _description_
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_broken_dataset(feature_is_none_list: List[int]):
"""Generate a fake dataset to test methods of SeqRecord where some features does not exist.
Params:
feature_is_none_list (List[str]): indices of data-frame that have missing features
Returns:
None
"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for i in range(seq_len):
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
if feature != "A100" or (i not in feature_is_none_list):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
else:
dataset[i][feature] = np.array(None)
record = RSeqRecord(rootdir)
return record, dataset, features
def build_seq_dataset():
"""Generate an aritificial dataset to test methods of SeqRecord, w"""
rootdir = "./output/seqrecord_test/"
seq_len = 10
features = {"s1": None, "i5": None, "i7": None, "v100": None, "A100": None}
dataset = [{} for _ in range(seq_len)]
for feature in features:
shape = (np.random.randint(1, 5), np.random.randint(2, 7))
dtype = np.random.choice(["float32", "int", "bool"])
for i in range(seq_len):
dataset[i][feature] = (
np.random.rand(shape[0], shape[1])
if dtype == "float32"
else np.ones(shape=shape)
)
record = RSeqRecord(rootdir)
return record, dataset, features
if __name__ == "__main__":
np.random.seed(0)
unittest.main()
| seqrecord/robot/tests/test_seqrecord.py | microsoft-seqrecord-55c8d91 | [
{
"filename": "seqrecord/robot/seqrecord.py",
"retrieved_chunk": " head4segment.append(item_idx)\n recordfile_idx = self.metadata[item_idx][\"file_idx\"]\n file2segment_items[recordfile_idx].append((is_segment_start, item_idx))\n return\n if sub_features is None:\n sub_features = list(self.features_written)\n else:\n assert all(\n feature in self.features_written for feature in sub_features\n ), \"Unknow features requested\"",
"score": 44.54889762899086
},
{
"filename": "seqrecord/robot/seqrecord.py",
"retrieved_chunk": " item_list = segment_proto[\"file2segment_items\"][recordfile_idx]\n recordfile_path = recordfileidx2path(self.recorddir, recordfile_idx)\n q = collections.deque()\n with open(recordfile_path, mode=\"rb\") as f:\n for is_segment_start, item_idx in item_list:\n q.append(\n (\n is_segment_start,\n self.read_frame(\n f, self.metadata[item_idx], segment_proto[\"features\"]",
"score": 35.963377584737316
},
{
"filename": "seqrecord/robot/seqrecord.py",
"retrieved_chunk": " segment_len (int): length of segment we are reading, 1< segment_len < sequence length\n sub_features: (Optional[List[str]]): features (modalities data) we need for each data item in segment to contain. If it is None,\n then we read all features.\n Returns:\n Dict[str, Any]: protocal needed for reading segments from data\n \"\"\"\n def has_sub_features(itemproto: Dict[str, Any]) -> bool:\n return all(not itemproto[feature][\"is_none\"] for feature in sub_features)\n def update_segmentproto(item_idx: int, is_segment_start: bool) -> None:\n if is_segment_start:",
"score": 26.615449820676183
},
{
"filename": "seqrecord/robot/seqrecord.py",
"retrieved_chunk": " shuffle_recordfile: bool: if we shuffle at the record file level when reading items in the record\n Yields:\n Generator[Dict[str, np.ndarray], None, None]: data item [feature->data]. All data items are being returned sequentially\n \"\"\"\n recordfiles = list(range(self.file_idx))\n for i in recordfiles:\n recordfile_path = recordfileidx2path(self.recorddir, i)\n endpoints = self.idx_range_of_files[i]\n with open(recordfile_path, mode=\"rb\") as f:\n for idx in range(endpoints[0], endpoints[1] + 1):",
"score": 26.41870126693682
},
{
"filename": "seqrecord/robot/seqrecord.py",
"retrieved_chunk": " update_segmentproto(q.popleft(), is_segment_start=False)\n # 1. new seq (including broken) added before queue pops out\n # the remaining elements in queue are completely useless\n # 2. new seq (including broken) added after queue has popped out\n # the remaining elements are not start of segment but are tails of some segment\n self.metadata_segment_cache[cache_key] = {\n \"segment_len\": segment_len,\n \"features\": sub_features,\n \"head4segment\": head4segment,\n \"file2segment_items\": file2segment_items,",
"score": 24.479784441028123
}
] | python | read_segments(idx4segment)): |
from functools import lru_cache
from typing import Optional
import openai
import tiktoken
from tiktoken import Encoding
from llm_client.llm_api_client.base_llm_api_client import BaseLLMAPIClient, LLMAPIClientConfig, ChatMessage
from llm_client.consts import PROMPT_KEY
INPUT_KEY = "input"
MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME = {
"gpt-3.5-turbo-0613": (3, 1),
"gpt-3.5-turbo-16k-0613": (3, 1),
"gpt-4-0314": (3, 1),
"gpt-4-32k-0314": (3, 1),
"gpt-4-0613": (3, 1),
"gpt-4-32k-0613": (3, 1),
# every message follows <|start|>{role/name}\n{content}<|end|>\n, if there's a name, the role is omitted
"gpt-3.5-turbo-0301": (4, -1),
}
class OpenAIClient(BaseLLMAPIClient):
def __init__(self, config: LLMAPIClientConfig):
super().__init__(config)
openai.api_key = self._api_key
openai.aiosession.set(self._session)
self._client = openai
async def text_completion(self, prompt: str, model: Optional[str] = None, temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, **kwargs) -> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs[PROMPT_KEY] = prompt
kwargs["top_p"] = top_p
kwargs["temperature"] = temperature
kwargs["max_tokens"] = max_tokens
completions = await self._client.Completion.acreate(headers=self._headers, **kwargs)
return [choice.text for choice in completions.choices]
async def chat_completion(self, messages: list[ChatMessage], temperature: float = 0,
max_tokens: int = 16, top_p: float = 1, model: Optional[str] = None, **kwargs) \
-> list[str]:
self._set_model_in_kwargs(kwargs, model)
kwargs["messages"] = [message.to_dict() for message in messages]
kwargs["temperature"] = temperature
kwargs["top_p"] = top_p
kwargs["max_tokens"] = max_tokens
completions = await self._client. | ChatCompletion.acreate(headers=self._headers, **kwargs) |
return [choice.message.content for choice in completions.choices]
async def embedding(self, text: str, model: Optional[str] = None, **kwargs) -> list[float]:
self._set_model_in_kwargs(kwargs, model)
kwargs[INPUT_KEY] = text
embeddings = await openai.Embedding.acreate(**kwargs)
return embeddings.data[0].embedding
async def get_tokens_count(self, text: str, model: Optional[str] = None, **kwargs) -> int:
if model is None:
model = self._default_model
return len(self._get_relevant_tokeniser(model).encode(text))
async def get_chat_tokens_count(self, messages: list[ChatMessage], model: Optional[str] = None) -> int:
"""
This is based on:
https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
"""
model = self._get_model_name_for_tokeniser(model)
encoding = self._get_relevant_tokeniser(model)
tokens_per_message, tokens_per_name = MODEL_NAME_TO_TOKENS_PER_MESSAGE_AND_TOKENS_PER_NAME[model]
num_tokens = 0
for message in messages:
num_tokens += tokens_per_message
num_tokens += len(encoding.encode(message.content))
num_tokens += len(encoding.encode(message.role.value))
if message.name:
num_tokens += len(encoding.encode(message.name))
num_tokens += tokens_per_name
num_tokens += 3 # every reply is primed with <|start|>assistant<|message|>
return num_tokens
def _get_model_name_for_tokeniser(self, model: Optional[str] = None) -> str:
if model is None:
model = self._default_model
if model in {
"gpt-3.5-turbo-0613",
"gpt-3.5-turbo-16k-0613",
"gpt-4-0314",
"gpt-4-32k-0314",
"gpt-4-0613",
"gpt-4-32k-0613",
}:
return model
elif model == "gpt-3.5-turbo-0301":
return model
elif "gpt-3.5-turbo" in model:
print("Warning: gpt-3.5-turbo may update over time. Returning tokeniser assuming gpt-3.5-turbo-0613.")
return "gpt-3.5-turbo-0613"
elif "gpt-4" in model:
print("Warning: gpt-4 may update over time. Returning tokeniser assuming gpt-4-0613.")
return "gpt-4-0613"
else:
raise NotImplementedError(
f"""not implemented for model {model}.
See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
)
@staticmethod
@lru_cache(maxsize=40)
def _get_relevant_tokeniser(model: str) -> Encoding:
return tiktoken.encoding_for_model(model)
| llm_client/llm_api_client/openai_client.py | uripeled2-llm-client-sdk-66af541 | [
{
"filename": "llm_client/llm_api_client/base_llm_api_client.py",
"retrieved_chunk": " async def chat_completion(self, messages: list[ChatMessage], temperature: float = 0,\n max_tokens: int = 16, model: Optional[str] = None, **kwargs) -> list[str]:\n raise NotImplementedError()\n async def embedding(self, text: str, model: Optional[str] = None, **kwargs) -> list[float]:\n raise NotImplementedError()\n async def get_chat_tokens_count(self, messages: list[ChatMessage], **kwargs) -> int:\n raise NotImplementedError()\n def _set_model_in_kwargs(self, kwargs, model: Optional[str]) -> None:\n if model is not None:\n kwargs[MODEL_KEY] = model",
"score": 80.25723665472347
},
{
"filename": "llm_client/llm_api_client/anthropic_client.py",
"retrieved_chunk": " async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: Optional[int] = None,\n temperature: float = 1, top_p: Optional[float] = None,\n **kwargs) -> \\\n list[str]:\n if max_tokens is None and kwargs.get(MAX_TOKENS_KEY) is None:\n raise ValueError(f\"max_tokens or {MAX_TOKENS_KEY} must be specified\")\n if top_p:\n kwargs[\"top_p\"] = top_p\n self._set_model_in_kwargs(kwargs, model)\n kwargs[PROMPT_KEY] = prompt",
"score": 71.44575057891137
},
{
"filename": "llm_client/llm_api_client/huggingface_client.py",
"retrieved_chunk": " self._base_url = BASE_URL\n if self._default_model is None:\n self._default_model = DEFAULT_MODEL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, max_tokens: Optional[int] = None, temperature: float = 1.0,\n model: Optional[str] = None, top_p: Optional[float] = None, **kwargs) -> list[str]:\n model = model or self._default_model\n kwargs[\"top_p\"] = top_p\n kwargs[INPUT_KEY] = prompt\n kwargs[TEMPERATURE_KEY] = temperature",
"score": 71.12698614874257
},
{
"filename": "llm_client/llm_api_client/aleph_alpha_client.py",
"retrieved_chunk": " if self._base_url is None:\n self._base_url = BASE_URL\n self._headers[AUTH_HEADER] = BEARER_TOKEN + self._api_key\n async def text_completion(self, prompt: str, model: Optional[str] = None, max_tokens: Optional[int] = None,\n temperature: float = 0,top_p: float = 0, **kwargs) -> \\\n list[str]:\n self._set_model_in_kwargs(kwargs, model)\n if max_tokens is None:\n raise ValueError(\"max_tokens must be specified\")\n kwargs[PROMPT_KEY] = prompt",
"score": 69.35935284075842
},
{
"filename": "llm_client/llm_api_client/anthropic_client.py",
"retrieved_chunk": " if self._base_url is None:\n self._base_url = BASE_URL\n self._anthropic = AsyncAnthropic()\n if self._headers.get(VERSION_HEADER) is None:\n self._headers[VERSION_HEADER] = self._anthropic.default_headers[VERSION_HEADER]\n self._headers[ACCEPT_HEADER] = ACCEPT_VALUE\n self._headers[AUTH_HEADER] = self._api_key\n async def chat_completion(self, messages: list[ChatMessage], model: Optional[str] = None,\n max_tokens: Optional[int] = None, temperature: float = 1, **kwargs) -> list[str]:\n return await self.text_completion(self.messages_to_text(messages), model, max_tokens, temperature, **kwargs)",
"score": 67.68418179801783
}
] | python | ChatCompletion.acreate(headers=self._headers, **kwargs) |
import pytest
from django.core.exceptions import ValidationError
from api import model_validators
class TestDecisionTreeValidator:
answer_1 = {
"tag": "ans1",
"text": "Answer 1",
"decision": None,
"next_question_tag": "q2",
}
answer_2 = {
"tag": "ans2",
"text": "Answer 2",
"decision": "decision1",
"next_question_tag": None,
}
answer_3 = {
"tag": "ans3",
"text": "Answer 3",
"decision": "decision2",
"next_question_tag": None,
}
answer_4 = {
"tag": "ans4",
"text": "Answer 4",
"decision": "decision3",
"next_question_tag": None,
}
question_1 = {
"tag": "q1",
"text": "Question 1",
"answers": [answer_1, answer_2],
}
question_2 = {
"tag": "q2",
"text": "Question 2",
"answers": [answer_3, answer_4],
}
def test_valid(self):
decision_tree = {
"start_question_tag": "q1",
"questions": [self.question_1, self.question_2],
}
model_validators. | DecisionTreeValidator.validate_tree(decision_tree) |
def test_miss_start(self):
decision_tree = {
"questions": [self.question_1, self.question_2],
}
with pytest.raises(ValidationError, match="missing value"):
model_validators.DecisionTreeValidator.validate_tree(decision_tree)
def test_wrong_start(self):
decision_tree = {
"start_question_tag": "w1",
"questions": [self.question_1, self.question_2],
}
with pytest.raises(ValidationError, match="not in decision tree"):
model_validators.DecisionTreeValidator.validate_tree(decision_tree)
def test_has_cycle(self):
question_2_loop = {
"tag": "q2",
"text": "Question 2",
"answers": [self.answer_1, self.answer_2],
}
decision_tree = {
"start_question_tag": "q1",
"questions": [self.question_1, question_2_loop],
}
with pytest.raises(ValidationError, match="decision tree has a cycle"):
model_validators.DecisionTreeValidator.validate_tree(decision_tree)
# the cycle testing is more complex, so adding some test cases here
class TestGraphIntegrity:
def test_topo_sort_base(self):
start_node = "q1"
g = {
"q1": ["q2", "q3"],
"q2": ["q3", "q5"],
"q3": ["q4", "q5"],
"q4": [],
"q5": [],
}
expected_order = ["q1", "q2", "q3", "q5", "q4"]
returned_order = model_validators.DecisionTreeValidator.topo_sort(start_node, g)
for e, r in zip(expected_order, returned_order):
assert e == r
def test_topo_sort_small_cycle(self):
start_node = "q1"
g = {
"q1": ["q2"],
"q2": ["q1"],
}
expected_order = ["q1", "q2", "q2"]
returned_order = model_validators.DecisionTreeValidator.topo_sort(start_node, g)
for e, r in zip(expected_order, returned_order):
assert e == r
def test_topo_sort_med_cycle(self):
start_node = "q1"
g = {
"q1": ["q2", "q3"],
"q2": ["q3", "q5"],
"q3": ["q4", "q1"],
"q4": ["q5"],
"q5": [],
}
expected_order = ["q1", "q2", "q3", "q4", "q5", "q1"]
returned_order = model_validators.DecisionTreeValidator.topo_sort(start_node, g)
for e, r in zip(expected_order, returned_order):
assert e == r
| cr-backend/tests/test_validators.py | shug2k-content-review-tool-93305bb | [
{
"filename": "cr-backend/api/models.py",
"retrieved_chunk": " )\n def save(self, *args, **kwargs):\n self.full_clean()\n super().save(*args, **kwargs)\n @staticmethod\n def default_decision_tree():\n return {\n \"start_question_tag\": \"is_violating\",\n \"questions\": [\n {",
"score": 27.995607325311397
},
{
"filename": "cr-backend/api/models.py",
"retrieved_chunk": " IMAGE = \"image\", \"Image\"\n def save(self, *args, **kwargs):\n self.full_clean()\n model_validators.ReviewValidator.validate_entity_type_and_content(\n self.entity_type, self.entity_content\n )\n super().save(*args, **kwargs)\n create_time = models.DateTimeField(auto_now_add=True)\n update_time = models.DateTimeField(auto_now=True)\n entity_id = models.CharField(max_length=128, default=None, blank=True, null=True)",
"score": 23.54650615442126
},
{
"filename": "cr-backend/tests/conftest.py",
"retrieved_chunk": " \"tag\": \"q1\",\n \"text\": \"Question 1\",\n \"answers\": [\n {\n \"tag\": \"a1\",\n \"text\": \"Answer 1\",\n },\n {\n \"tag\": \"a2\",\n \"text\": \"Answer 2\",",
"score": 20.38461979751243
},
{
"filename": "cr-backend/api/model_validators.py",
"retrieved_chunk": " f\"Question {question.tag} has no text! Please add text to this question\"\n )\n # check if start question is in question set\n if tree_obj.start_question_tag not in question_set:\n raise ValidationError(\n f\"Start question {tree_obj.start_question_tag} not in decision tree!\"\n )\n # validate the graph for missing questions, extra questions, cycles\n question_graph = construct_tree_graph(tree_obj)\n missing_qs = DecisionTreeValidator.missing_questions(question_graph)",
"score": 14.843227289445277
},
{
"filename": "cr-backend/api/modules.py",
"retrieved_chunk": " decision: str | None\n next_question_tag: str | None\n@dataclass\nclass Question:\n tag: str\n text: str\n answers: list[Answer]\n@dataclass\nclass DecisionTree:\n start_question_tag: str",
"score": 13.908717577708032
}
] | python | DecisionTreeValidator.validate_tree(decision_tree) |
import pytest
import json
from api.models import QueueCR
@pytest.mark.django_db
def test_queues_route(client, queue_1, queue_2):
response = client.get("/queues")
data = json.loads(response.content)
assert response.status_code == 200
assert data["queues"][0]["name"] == queue_1.name
assert data["queues"][1]["name"] == queue_2.name
@pytest.mark.django_db
def test_create_queue_route_no_tree(client):
response = client.post(
"/create-queue", {"name": "test1"}, content_type="application/json"
)
assert response.status_code == 200
@pytest.mark.django_db
def test_create_queue_route_with_tree(client, base_decision_tree):
response = client.post(
"/create-queue",
{"name": "test1", "decision_tree_name": "test2"},
content_type="application/json",
)
assert response.status_code == 200
@pytest.mark.django_db
def test_create_queue_route_wrong_tree(client):
response = client.post(
"/create-queue",
{"name": "test1", "decision_tree_name": "test2"},
content_type="application/json",
)
assert response.status_code == 400
assert response.content.decode() == "decision tree 'test2' does not exist!"
@pytest.mark.django_db
def test_modify_queue_route(client, queue_1, base_decision_tree):
assert queue_1.decision_tree is None
response = client.post(
"/modify-queue/" + queue_1.name,
{"decision_tree_name": base_decision_tree.name},
content_type="application/json",
)
assert response.status_code == 200
updated_queue_1 = QueueCR. | objects.get(id=queue_1.id) |
assert updated_queue_1.decision_tree is not None
@pytest.mark.django_db
def test_modify_queue_route_wrong_queue(client, queue_1, base_decision_tree):
response = client.post(
"/modify-queue/" + queue_1.name + "_random",
{"decision_tree_name": base_decision_tree.name},
content_type="application/json",
)
assert response.status_code == 400
assert (
response.content.decode()
== f"Queue '{queue_1.name+'_random'}' does not exist! Please create it first"
)
@pytest.mark.django_db
def test_modify_queue_route_wrong_tree(client, queue_1):
response = client.post(
"/modify-queue/" + queue_1.name,
{"decision_tree_name": "tree1"},
content_type="application/json",
)
assert response.status_code == 400
assert response.content.decode() == f"decision tree 'tree1' does not exist!"
@pytest.mark.django_db
def test_modify_queue_route_non_unique_name(client, queue_1, queue_2):
response = client.post(
"/modify-queue/" + queue_1.name,
{"name": queue_2.name},
content_type="application/json",
)
assert response.status_code == 400
assert (
response.content.decode()
== f"Queue name '{queue_2.name}' already exists! Please use a different name"
)
@pytest.mark.django_db
def test_delete_queue_route(client, queue_1):
pre_delete_queue_1 = QueueCR.objects.filter(id=queue_1.id).first()
assert pre_delete_queue_1 is not None
response = client.post(
"/delete-queue/" + queue_1.name,
content_type="application/json",
)
assert response.status_code == 200
post_delete_queue_1 = QueueCR.objects.filter(id=queue_1.id).first()
assert post_delete_queue_1 is None
@pytest.mark.django_db
def test_delete_queue_route_wrong_name(client, queue_1):
response = client.post(
"/delete-queue/" + queue_1.name + "_random",
content_type="application/json",
)
assert response.status_code == 400
assert (
response.content.decode() == f"Queue '{queue_1.name+'_random'}' does not exist!"
)
| cr-backend/tests/test_queue_routes.py | shug2k-content-review-tool-93305bb | [
{
"filename": "cr-backend/tests/test_decision_tree_routes.py",
"retrieved_chunk": " assert response.status_code == 200\n updated_decision_tree = DecisionTreeCR.objects.get(id=base_decision_tree.id)\n assert updated_decision_tree.name == \"Test Decision Tree\"\[email protected]_db\ndef test_modify_decision_tree_route_wrong_name(client, base_decision_tree):\n response = client.post(\n \"/modify-decision-tree/\" + base_decision_tree.name + \"_random\",\n {\"name\": \"Test Decision Tree\"},\n content_type=\"application/json\",\n )",
"score": 45.96979405413953
},
{
"filename": "cr-backend/tests/test_decision_tree_routes.py",
"retrieved_chunk": " assert pre_delete_decision_tree is not None\n response = client.post(\n \"/delete-decision-tree/\" + base_decision_tree.name,\n content_type=\"application/json\",\n )\n assert response.status_code == 200\n post_delete_decision_tree = DecisionTreeCR.objects.filter(\n id=base_decision_tree.id\n ).first()\n assert post_delete_decision_tree is None",
"score": 45.09156141195356
},
{
"filename": "cr-backend/tests/test_review_routes.py",
"retrieved_chunk": " \"queue_name\": queue_1.name,\n },\n content_type=\"application/json\",\n )\n assert response.status_code == 400\n assert \"'img' is not a valid choice\" in response.content.decode()\[email protected]_db\ndef test_create_review_route_content_not_url_for_image(client, queue_1):\n response = client.post(\n \"/create-review\",",
"score": 42.18207726194838
},
{
"filename": "cr-backend/tests/test_decision_tree_routes.py",
"retrieved_chunk": " )\n assert response.status_code == 400\n assert \"with this Name already exists\" in response.content.decode()\[email protected]_db\ndef test_modify_decision_tree_route(client, base_decision_tree):\n response = client.post(\n \"/modify-decision-tree/\" + base_decision_tree.name,\n {\"name\": \"Test Decision Tree\"},\n content_type=\"application/json\",\n )",
"score": 36.16852158244369
},
{
"filename": "cr-backend/tests/test_decision_tree_routes.py",
"retrieved_chunk": "@pytest.mark.django_db\ndef test_delete_decision_tree_route_wrong_name(client, base_decision_tree):\n response = client.post(\n \"/delete-decision-tree/\" + base_decision_tree.name + \"_random\",\n content_type=\"application/json\",\n )\n assert response.status_code == 400\n assert (\n response.content.decode()\n == f\"Decision tree '{base_decision_tree.name+'_random'}' does not exist!\"",
"score": 34.839203613698835
}
] | python | objects.get(id=queue_1.id) |
import pytest
from api.models import DecisionTreeCR
@pytest.fixture
def basic_violating_json_tree():
return {
"start_question_tag": "is_violating",
"questions": [
{
"tag": "is_violating",
"text": "Is this content violating?",
"answers": [
{
"tag": "yes",
"text": "Yes",
"decision": "yes_violating",
},
{
"tag": "no",
"text": "No",
"decision": "no_violating",
},
],
},
],
}
@pytest.mark.django_db
def test_create_decision_tree_route(client, basic_violating_json_tree):
response = client.post(
"/create-decision-tree",
{"name": "Basic violating", "tree": basic_violating_json_tree},
content_type="application/json",
)
assert response.status_code == 200
@pytest.mark.django_db
def test_create_decision_tree_route_empty_tree(client):
response = client.post(
"/create-decision-tree",
{"name": "Basic violating", "tree": {}},
content_type="application/json",
)
assert response.status_code == 400
assert response.content.decode() == "('tree', ['This field cannot be blank.'])"
@pytest.mark.django_db
def test_create_decision_tree_route_duplicate_name(
client, basic_violating_json_tree, base_decision_tree
):
response = client.post(
"/create-decision-tree",
{"name": base_decision_tree.name, "tree": basic_violating_json_tree},
content_type="application/json",
)
assert response.status_code == 400
assert "with this Name already exists" in response.content.decode()
@pytest.mark.django_db
def test_modify_decision_tree_route(client, base_decision_tree):
response = client.post(
"/modify-decision-tree/" + base_decision_tree.name,
{"name": "Test Decision Tree"},
content_type="application/json",
)
assert response.status_code == 200
updated_decision_tree = DecisionTreeCR. | objects.get(id=base_decision_tree.id) |
assert updated_decision_tree.name == "Test Decision Tree"
@pytest.mark.django_db
def test_modify_decision_tree_route_wrong_name(client, base_decision_tree):
response = client.post(
"/modify-decision-tree/" + base_decision_tree.name + "_random",
{"name": "Test Decision Tree"},
content_type="application/json",
)
assert response.status_code == 400
assert (
response.content.decode()
== f"Decision tree '{base_decision_tree.name + '_random'}' does not exist!"
)
@pytest.mark.django_db
def test_delete_decision_tree_route(client, base_decision_tree):
pre_delete_decision_tree = DecisionTreeCR.objects.filter(
id=base_decision_tree.id
).first()
assert pre_delete_decision_tree is not None
response = client.post(
"/delete-decision-tree/" + base_decision_tree.name,
content_type="application/json",
)
assert response.status_code == 200
post_delete_decision_tree = DecisionTreeCR.objects.filter(
id=base_decision_tree.id
).first()
assert post_delete_decision_tree is None
@pytest.mark.django_db
def test_delete_decision_tree_route_wrong_name(client, base_decision_tree):
response = client.post(
"/delete-decision-tree/" + base_decision_tree.name + "_random",
content_type="application/json",
)
assert response.status_code == 400
assert (
response.content.decode()
== f"Decision tree '{base_decision_tree.name+'_random'}' does not exist!"
)
| cr-backend/tests/test_decision_tree_routes.py | shug2k-content-review-tool-93305bb | [
{
"filename": "cr-backend/tests/test_queue_routes.py",
"retrieved_chunk": " )\n assert response.status_code == 200\n updated_queue_1 = QueueCR.objects.get(id=queue_1.id)\n assert updated_queue_1.decision_tree is not None\[email protected]_db\ndef test_modify_queue_route_wrong_queue(client, queue_1, base_decision_tree):\n response = client.post(\n \"/modify-queue/\" + queue_1.name + \"_random\",\n {\"decision_tree_name\": base_decision_tree.name},\n content_type=\"application/json\",",
"score": 51.03991124570878
},
{
"filename": "cr-backend/tests/test_queue_routes.py",
"retrieved_chunk": " )\n assert response.status_code == 400\n assert response.content.decode() == \"decision tree 'test2' does not exist!\"\[email protected]_db\ndef test_modify_queue_route(client, queue_1, base_decision_tree):\n assert queue_1.decision_tree is None\n response = client.post(\n \"/modify-queue/\" + queue_1.name,\n {\"decision_tree_name\": base_decision_tree.name},\n content_type=\"application/json\",",
"score": 45.51482529544693
},
{
"filename": "cr-backend/tests/test_queue_routes.py",
"retrieved_chunk": "@pytest.mark.django_db\ndef test_create_queue_route_no_tree(client):\n response = client.post(\n \"/create-queue\", {\"name\": \"test1\"}, content_type=\"application/json\"\n )\n assert response.status_code == 200\[email protected]_db\ndef test_create_queue_route_with_tree(client, base_decision_tree):\n response = client.post(\n \"/create-queue\",",
"score": 43.27812944878296
},
{
"filename": "cr-backend/tests/test_review_routes.py",
"retrieved_chunk": " )\[email protected]_db\ndef test_get_review_route_pulls_tree(client, text_review_q2, base_decision_tree):\n response = client.get(\"/review/\" + str(text_review_q2.id))\n data = json.loads(response.content)\n assert response.status_code == 200\n # assumes queue_2 has base_decision_tree (see conftest.py for setup)\n assert (\n data[\"decision_tree\"][\"start_question_tag\"]\n == base_decision_tree.tree[\"start_question_tag\"]",
"score": 41.76925299868586
},
{
"filename": "cr-backend/tests/test_queue_routes.py",
"retrieved_chunk": " {\"decision_tree_name\": \"tree1\"},\n content_type=\"application/json\",\n )\n assert response.status_code == 400\n assert response.content.decode() == f\"decision tree 'tree1' does not exist!\"\[email protected]_db\ndef test_modify_queue_route_non_unique_name(client, queue_1, queue_2):\n response = client.post(\n \"/modify-queue/\" + queue_1.name,\n {\"name\": queue_2.name},",
"score": 33.1889414707278
}
] | python | objects.get(id=base_decision_tree.id) |
from .tools.swoopyui_host import swoopyui_host_setup
from .tools.check_platform import is_device_a_ios, is_device_a_mac
from .tools.run_target import run_the_target
from .tools.run_swiftUI_ios import prepare_swiftUI_for_ios
from .tools.run_swiftUI import run_swiftUI_app
from .tools.get_free_port import get_free_port
from .view import View
from flask import Flask, request
import logging, threading, tempfile, time
class app:
def __init__(self, target, base_name="__main__", debug:bool=False, for_preview=False) -> None:
self.target_function = target
self.base_name = base_name
self.debug = debug
self.for_preview = for_preview
self.host_port = get_free_port()
self.next_get_updates_responses = []
self.client_view = View(host_port=self.host_port, host_app_class=self)
# start the host
print("Host started..")
self.host()
def host (self):
self.flask_app = Flask(self.base_name)
flask_app = self.flask_app
# Set the logging level to ignore warnings
if self.debug == False and self.for_preview == False:
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)
@flask_app.route("/start_target_function")
def start_target_function ():
print("A swiftUI client connected..")
threading.Thread(target=run_the_target, args=[self.target_function, [self.client_view]]).start()
return '{"ok":true}'
@flask_app.route("/get_updates")
def get_updates():
updts = list(self.next_get_updates_responses)
self.next_get_updates_responses.clear()
return {
"updts" : updts
}
@flask_app.route("/push_update", methods=['POST'])
def push_update():
self.client_view. | process_client_events(request.json) |
return ""
if is_device_a_ios() and self.for_preview == False:
prepare_swiftUI_for_ios(port=self.host_port)
elif is_device_a_mac() and self.for_preview == False:
tmp_dir = tempfile.mkdtemp()
threading.Thread(target=run_swiftUI_app, args=[self.host_port, tmp_dir], daemon=True).start()
if self.for_preview:
print("Your preview host ready, this is the host data:\n\n")
threading.Thread(target=self.no_logging_after_3_sec).start()
flask_app.run(host="0.0.0.0", port=self.host_port)
else:
flask_app.run(host="localhost", port=self.host_port)
def no_logging_after_3_sec (self):
time.sleep(3)
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR) | swoopyui/swoopyui.py | SKbarbon-swoopyui-a4fb25d | [
{
"filename": "swoopyui/tools/swoopyui_host.py",
"retrieved_chunk": " print(updts)\n return {\n \"updts\" : updts\n }\n @flask_app.route(\"/push_update\")\n def push_update():\n return \"\"",
"score": 52.68580410155602
},
{
"filename": "swoopyui/tools/swoopyui_host.py",
"retrieved_chunk": "from flask import request, Flask\ndef swoopyui_host_setup (flask_app:Flask, target_function, client_view):\n @flask_app.route(\"/start_target_function\")\n def start_target_function ():\n target_function(client_view)\n return '{\"ok\":true}'\n @flask_app.route(\"/get_updates\")\n def get_updates():\n updts = list(client_view.next_updates)\n client_view.next_updates.clear()",
"score": 50.31071745963864
},
{
"filename": "swoopyui/view.py",
"retrieved_chunk": " self.platform = event_dict['content']['platform']\n def __add_to_next_update_requests(self, update_dict):\n \"\"\"Add an update request to the client.\"\"\"\n # print(update_dict)\n self.__host_app_class.next_get_updates_responses.append(update_dict)\n @property\n def next_updates (self):\n return self.__next_updates",
"score": 21.320123717942124
},
{
"filename": "swoopyui/view.py",
"retrieved_chunk": " def update (self, subview:SubView=None):\n if subview == None:\n pass\n else:\n subview.update_id = self.get_new_subview_update_id()\n subview.vdata['update_id'] = subview.update_id\n self.__add_to_next_update_requests(update_dict=onUpdateSubviewProps(subview=subview).raw)\n def add_to_subviews_history (self, subv:SubView):\n self.__subviews_history.append(subv)\n def process_client_events (self, event_dict:dict):",
"score": 11.767922741267608
},
{
"filename": "swoopyui/views/navigationsplitview.py",
"retrieved_chunk": " parent_view=self,\n main_view=self.main_view\n )\n self.subviews.append(subview)\n self.vdata['sub_views3'].append(subview.vdata)\n self.main_view.add_to_subviews_history(subview)\n self.update()\n def add_to_detail_toolbar (self, subviews:list):\n \"\"\"Add to detail page toolbar.\"\"\"\n if self.parent_view == None or self.main_view == None: return",
"score": 10.230900517118366
}
] | python | process_client_events(request.json) |
import swoopyui
def main(view:swoopyui.View):
def on_add_num (cls):
number.content = str(number.content) + cls.content
number.update()
def on_operation (cls):
number.content = str(eval(number.content))
number.update()
nav = swoopyui.NavigationSplitView("Calculator")
view.add(nav)
number = swoopyui.Text("1", size=24)
nav.add([number])
tool_stk = swoopyui.HStack()
row1 = swoopyui.HStack()
row2 = swoopyui.HStack()
row3 = swoopyui.HStack()
row4 = swoopyui.HStack()
nav.add([
tool_stk,
row1,
row2,
row3,
row4
])
for t in ["+", "-", "*"]:
tool_stk.add([swoopyui. | ElevatedButton(f"{t}", on_click=on_add_num, width=50, height=50, bgcolor="orange")]) |
for r1 in [1, 2, 3]:
row1.add([swoopyui.ElevatedButton(f"{r1}", on_click=on_add_num, width=50, height=50)])
for r2 in [4, 5, 6]:
row2.add([swoopyui.ElevatedButton(f"{r2}", on_click=on_add_num, width=50, height=50)])
for r3 in [7, 8, 9]:
row3.add([swoopyui.ElevatedButton(f"{r3}", on_click=on_add_num, width=50, height=50)])
row4.add([
swoopyui.ElevatedButton(f"0", on_click=on_add_num, width=50, height=50),
swoopyui.ElevatedButton(f"=", on_click=on_operation, width=50, height=50, bgcolor="orange"),
swoopyui.ElevatedButton(f".", on_click=on_add_num, width=50, height=50)
])
swoopyui.app(target=main) | examples/calculator.py | SKbarbon-swoopyui-a4fb25d | [
{
"filename": "swoopyui_app/main.py",
"retrieved_chunk": " number_label = swoopyui.Text(\"1\", size=28)\n nav.add([number_label])\n tool_row = swoopyui.HStack()\n nav.add([tool_row])\n plus_btn = swoopyui.ElevatedButton(\"+\", width=40, bgcolor=\"orange\", on_click=on_add_number)\n minus_btn = swoopyui.ElevatedButton(\"-\", width=40, bgcolor=\"orange\", on_click=on_add_number)\n multiply_btn = swoopyui.ElevatedButton(\"*\", width=40, bgcolor=\"orange\", on_click=on_add_number)\n tool_row.add([\n plus_btn,\n minus_btn,",
"score": 32.86521202730694
},
{
"filename": "swoopyui_app/main.py",
"retrieved_chunk": " for r1 in [1, 2, 3]:\n row_one.add([swoopyui.ElevatedButton(f\"{r1}\", width=40, on_click=on_add_number)])\n for r2 in [4, 5, 6]:\n row_two.add([swoopyui.ElevatedButton(f\"{r2}\", width=40, on_click=on_add_number)])\n for r3 in [7, 8, 9]:\n row_three.add([swoopyui.ElevatedButton(f\"{r3}\", width=40, on_click=on_add_number)])\n nav.add([swoopyui.ElevatedButton(\"=\", on_click=on_opration, bgcolor=\"pink\")])",
"score": 32.02038920693598
},
{
"filename": "examples/to_do.py",
"retrieved_chunk": " nav.add([top_hsatck])\n tf = swoopyui.TextField(\"What is your next task?\")\n top_hsatck.add([\n swoopyui.Text(\" \"),\n tf,\n swoopyui.ElevatedButton(\"+\", on_click=on_add_new_task),\n swoopyui.Text(\" \")\n ])\n scroll_view = swoopyui.ScrollView()\n nav.add([scroll_view])",
"score": 19.45245483776429
},
{
"filename": "examples/to_do.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_add_new_task (cls):\n task = tf.content\n scroll_view.add([swoopyui.Text(f\"{task}\")])\n tf.content = \"\"\n tf.update()\n nav = swoopyui.NavigationSplitView(\"To-do\")\n view.add(nav)\n top_hsatck = swoopyui.HStack()",
"score": 16.042172480391425
},
{
"filename": "examples/counter.py",
"retrieved_chunk": " plus_btn = swoopyui.ElevatedButton(\"+\", on_click=on_p)\n number = swoopyui.Text(\"0\")\n minus_btn = swoopyui.ElevatedButton(\"-\", on_click=on_m)\n hstack.add([\n plus_btn,\n number,\n minus_btn\n ])\nswoopyui.app(target=main)",
"score": 15.070503737802438
}
] | python | ElevatedButton(f"{t}", on_click=on_add_num, width=50, height=50, bgcolor="orange")]) |
import swoopyui
def main (view:swoopyui.View):
def on_add_number (cls:swoopyui.ElevatedButton):
number_label.content = str(number_label.content) + str(cls.content)
number_label.update()
def on_opration (cls:swoopyui.ElevatedButton):
number_label.content = str(eval(number_label.content))
number_label.update()
nav = swoopyui.NavigationSplitView("Calculator")
view.add(nav)
number_label = swoopyui. | Text("1", size=28) |
nav.add([number_label])
tool_row = swoopyui.HStack()
nav.add([tool_row])
plus_btn = swoopyui.ElevatedButton("+", width=40, bgcolor="orange", on_click=on_add_number)
minus_btn = swoopyui.ElevatedButton("-", width=40, bgcolor="orange", on_click=on_add_number)
multiply_btn = swoopyui.ElevatedButton("*", width=40, bgcolor="orange", on_click=on_add_number)
tool_row.add([
plus_btn,
minus_btn,
multiply_btn
])
row_one = swoopyui.HStack()
row_two = swoopyui.HStack()
row_three = swoopyui.HStack()
nav.add([
row_one,
row_two,
row_three
])
for r1 in [1, 2, 3]:
row_one.add([swoopyui.ElevatedButton(f"{r1}", width=40, on_click=on_add_number)])
for r2 in [4, 5, 6]:
row_two.add([swoopyui.ElevatedButton(f"{r2}", width=40, on_click=on_add_number)])
for r3 in [7, 8, 9]:
row_three.add([swoopyui.ElevatedButton(f"{r3}", width=40, on_click=on_add_number)])
nav.add([swoopyui.ElevatedButton("=", on_click=on_opration, bgcolor="pink")]) | swoopyui_app/main.py | SKbarbon-swoopyui-a4fb25d | [
{
"filename": "examples/calculator.py",
"retrieved_chunk": "import swoopyui\ndef main(view:swoopyui.View):\n def on_add_num (cls):\n number.content = str(number.content) + cls.content\n number.update()\n def on_operation (cls):\n number.content = str(eval(number.content))\n number.update()\n nav = swoopyui.NavigationSplitView(\"Calculator\")\n view.add(nav)",
"score": 75.7189100482814
},
{
"filename": "examples/to_do.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_add_new_task (cls):\n task = tf.content\n scroll_view.add([swoopyui.Text(f\"{task}\")])\n tf.content = \"\"\n tf.update()\n nav = swoopyui.NavigationSplitView(\"To-do\")\n view.add(nav)\n top_hsatck = swoopyui.HStack()",
"score": 57.86448789640661
},
{
"filename": "examples/counter.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_p(cls):\n number.content = str(int(number.content)+1)\n number.update()\n def on_m (cls):\n number.content = str(int(number.content)-1)\n number.update()\n hstack = swoopyui.HStack()\n view.add(hstack)",
"score": 56.90280759614027
},
{
"filename": "examples/to_do.py",
"retrieved_chunk": " nav.add([top_hsatck])\n tf = swoopyui.TextField(\"What is your next task?\")\n top_hsatck.add([\n swoopyui.Text(\" \"),\n tf,\n swoopyui.ElevatedButton(\"+\", on_click=on_add_new_task),\n swoopyui.Text(\" \")\n ])\n scroll_view = swoopyui.ScrollView()\n nav.add([scroll_view])",
"score": 36.917708001753766
},
{
"filename": "examples/calculator.py",
"retrieved_chunk": " number = swoopyui.Text(\"1\", size=24)\n nav.add([number])\n tool_stk = swoopyui.HStack()\n row1 = swoopyui.HStack()\n row2 = swoopyui.HStack()\n row3 = swoopyui.HStack()\n row4 = swoopyui.HStack()\n nav.add([\n tool_stk,\n row1,",
"score": 35.40796180745116
}
] | python | Text("1", size=28) |
import swoopyui
def main(view:swoopyui.View):
def on_add_num (cls):
number.content = str(number.content) + cls.content
number.update()
def on_operation (cls):
number.content = str(eval(number.content))
number.update()
nav = swoopyui.NavigationSplitView("Calculator")
view.add(nav)
number = swoopyui. | Text("1", size=24) |
nav.add([number])
tool_stk = swoopyui.HStack()
row1 = swoopyui.HStack()
row2 = swoopyui.HStack()
row3 = swoopyui.HStack()
row4 = swoopyui.HStack()
nav.add([
tool_stk,
row1,
row2,
row3,
row4
])
for t in ["+", "-", "*"]:
tool_stk.add([swoopyui.ElevatedButton(f"{t}", on_click=on_add_num, width=50, height=50, bgcolor="orange")])
for r1 in [1, 2, 3]:
row1.add([swoopyui.ElevatedButton(f"{r1}", on_click=on_add_num, width=50, height=50)])
for r2 in [4, 5, 6]:
row2.add([swoopyui.ElevatedButton(f"{r2}", on_click=on_add_num, width=50, height=50)])
for r3 in [7, 8, 9]:
row3.add([swoopyui.ElevatedButton(f"{r3}", on_click=on_add_num, width=50, height=50)])
row4.add([
swoopyui.ElevatedButton(f"0", on_click=on_add_num, width=50, height=50),
swoopyui.ElevatedButton(f"=", on_click=on_operation, width=50, height=50, bgcolor="orange"),
swoopyui.ElevatedButton(f".", on_click=on_add_num, width=50, height=50)
])
swoopyui.app(target=main) | examples/calculator.py | SKbarbon-swoopyui-a4fb25d | [
{
"filename": "examples/counter.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_p(cls):\n number.content = str(int(number.content)+1)\n number.update()\n def on_m (cls):\n number.content = str(int(number.content)-1)\n number.update()\n hstack = swoopyui.HStack()\n view.add(hstack)",
"score": 100.80534382900659
},
{
"filename": "swoopyui_app/main.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_add_number (cls:swoopyui.ElevatedButton):\n number_label.content = str(number_label.content) + str(cls.content)\n number_label.update()\n def on_opration (cls:swoopyui.ElevatedButton):\n number_label.content = str(eval(number_label.content))\n number_label.update()\n nav = swoopyui.NavigationSplitView(\"Calculator\")\n view.add(nav)",
"score": 65.77443247353378
},
{
"filename": "examples/counter.py",
"retrieved_chunk": " plus_btn = swoopyui.ElevatedButton(\"+\", on_click=on_p)\n number = swoopyui.Text(\"0\")\n minus_btn = swoopyui.ElevatedButton(\"-\", on_click=on_m)\n hstack.add([\n plus_btn,\n number,\n minus_btn\n ])\nswoopyui.app(target=main)",
"score": 53.894236081546865
},
{
"filename": "examples/to_do.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_add_new_task (cls):\n task = tf.content\n scroll_view.add([swoopyui.Text(f\"{task}\")])\n tf.content = \"\"\n tf.update()\n nav = swoopyui.NavigationSplitView(\"To-do\")\n view.add(nav)\n top_hsatck = swoopyui.HStack()",
"score": 49.73002186717861
},
{
"filename": "swoopyui/views/text.py",
"retrieved_chunk": "from .subview import SubView\nclass Text (SubView):\n def __init__ (self, content:str, color:str=\"primery\", size:int=18):\n super().__init__()\n self.content : str = content\n self.color : str = color\n self.size : str = size\n self.vdata.update({\n \"name\" : \"Text\",\n \"props\" : {",
"score": 25.28727092541943
}
] | python | Text("1", size=24) |
import swoopyui
def main (view:swoopyui.View):
def on_p(cls):
number.content = str(int(number.content)+1)
number.update()
def on_m (cls):
number.content = str(int(number.content)-1)
number.update()
hstack = swoopyui.HStack()
view.add(hstack)
plus_btn = swoopyui. | ElevatedButton("+", on_click=on_p) |
number = swoopyui.Text("0")
minus_btn = swoopyui.ElevatedButton("-", on_click=on_m)
hstack.add([
plus_btn,
number,
minus_btn
])
swoopyui.app(target=main) | examples/counter.py | SKbarbon-swoopyui-a4fb25d | [
{
"filename": "examples/calculator.py",
"retrieved_chunk": "import swoopyui\ndef main(view:swoopyui.View):\n def on_add_num (cls):\n number.content = str(number.content) + cls.content\n number.update()\n def on_operation (cls):\n number.content = str(eval(number.content))\n number.update()\n nav = swoopyui.NavigationSplitView(\"Calculator\")\n view.add(nav)",
"score": 85.2855784927176
},
{
"filename": "examples/calculator.py",
"retrieved_chunk": " number = swoopyui.Text(\"1\", size=24)\n nav.add([number])\n tool_stk = swoopyui.HStack()\n row1 = swoopyui.HStack()\n row2 = swoopyui.HStack()\n row3 = swoopyui.HStack()\n row4 = swoopyui.HStack()\n nav.add([\n tool_stk,\n row1,",
"score": 54.97937471748022
},
{
"filename": "swoopyui_app/main.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_add_number (cls:swoopyui.ElevatedButton):\n number_label.content = str(number_label.content) + str(cls.content)\n number_label.update()\n def on_opration (cls:swoopyui.ElevatedButton):\n number_label.content = str(eval(number_label.content))\n number_label.update()\n nav = swoopyui.NavigationSplitView(\"Calculator\")\n view.add(nav)",
"score": 43.9284347249922
},
{
"filename": "examples/to_do.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_add_new_task (cls):\n task = tf.content\n scroll_view.add([swoopyui.Text(f\"{task}\")])\n tf.content = \"\"\n tf.update()\n nav = swoopyui.NavigationSplitView(\"To-do\")\n view.add(nav)\n top_hsatck = swoopyui.HStack()",
"score": 33.84287341031583
},
{
"filename": "swoopyui_app/main.py",
"retrieved_chunk": " number_label = swoopyui.Text(\"1\", size=28)\n nav.add([number_label])\n tool_row = swoopyui.HStack()\n nav.add([tool_row])\n plus_btn = swoopyui.ElevatedButton(\"+\", width=40, bgcolor=\"orange\", on_click=on_add_number)\n minus_btn = swoopyui.ElevatedButton(\"-\", width=40, bgcolor=\"orange\", on_click=on_add_number)\n multiply_btn = swoopyui.ElevatedButton(\"*\", width=40, bgcolor=\"orange\", on_click=on_add_number)\n tool_row.add([\n plus_btn,\n minus_btn,",
"score": 27.519707291005115
}
] | python | ElevatedButton("+", on_click=on_p) |
import swoopyui
def main (view:swoopyui.View):
def on_p(cls):
number.content = str(int(number.content)+1)
number.update()
def on_m (cls):
number.content = str(int(number.content)-1)
number.update()
hstack = swoopyui.HStack()
view.add(hstack)
plus_btn = swoopyui.ElevatedButton("+", on_click=on_p)
number = swoopyui. | Text("0") |
minus_btn = swoopyui.ElevatedButton("-", on_click=on_m)
hstack.add([
plus_btn,
number,
minus_btn
])
swoopyui.app(target=main) | examples/counter.py | SKbarbon-swoopyui-a4fb25d | [
{
"filename": "examples/calculator.py",
"retrieved_chunk": "import swoopyui\ndef main(view:swoopyui.View):\n def on_add_num (cls):\n number.content = str(number.content) + cls.content\n number.update()\n def on_operation (cls):\n number.content = str(eval(number.content))\n number.update()\n nav = swoopyui.NavigationSplitView(\"Calculator\")\n view.add(nav)",
"score": 88.4663223709576
},
{
"filename": "examples/calculator.py",
"retrieved_chunk": " number = swoopyui.Text(\"1\", size=24)\n nav.add([number])\n tool_stk = swoopyui.HStack()\n row1 = swoopyui.HStack()\n row2 = swoopyui.HStack()\n row3 = swoopyui.HStack()\n row4 = swoopyui.HStack()\n nav.add([\n tool_stk,\n row1,",
"score": 66.95097009084598
},
{
"filename": "swoopyui_app/main.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_add_number (cls:swoopyui.ElevatedButton):\n number_label.content = str(number_label.content) + str(cls.content)\n number_label.update()\n def on_opration (cls:swoopyui.ElevatedButton):\n number_label.content = str(eval(number_label.content))\n number_label.update()\n nav = swoopyui.NavigationSplitView(\"Calculator\")\n view.add(nav)",
"score": 40.31007366036084
},
{
"filename": "examples/to_do.py",
"retrieved_chunk": "import swoopyui\ndef main (view:swoopyui.View):\n def on_add_new_task (cls):\n task = tf.content\n scroll_view.add([swoopyui.Text(f\"{task}\")])\n tf.content = \"\"\n tf.update()\n nav = swoopyui.NavigationSplitView(\"To-do\")\n view.add(nav)\n top_hsatck = swoopyui.HStack()",
"score": 35.05918191415926
},
{
"filename": "swoopyui_app/main.py",
"retrieved_chunk": " number_label = swoopyui.Text(\"1\", size=28)\n nav.add([number_label])\n tool_row = swoopyui.HStack()\n nav.add([tool_row])\n plus_btn = swoopyui.ElevatedButton(\"+\", width=40, bgcolor=\"orange\", on_click=on_add_number)\n minus_btn = swoopyui.ElevatedButton(\"-\", width=40, bgcolor=\"orange\", on_click=on_add_number)\n multiply_btn = swoopyui.ElevatedButton(\"*\", width=40, bgcolor=\"orange\", on_click=on_add_number)\n tool_row.add([\n plus_btn,\n minus_btn,",
"score": 32.80552196576377
}
] | python | Text("0") |
"""This module contains functions for interacting with the Twitter API."""
from __future__ import annotations
import pandas as pd
import tweepy
from . import AutoGPTTwitter
plugin = AutoGPTTwitter()
def post_tweet(tweet_text: str) -> str:
"""Posts a tweet to twitter.
Args:
tweet (str): The tweet to post.
Returns:
str: The tweet that was posted.
"""
_tweetID = plugin. | api.update_status(status=tweet_text) |
return f"Success! Tweet: {_tweetID.text}"
def post_reply(tweet_text: str, tweet_id: int) -> str:
"""Posts a reply to a tweet.
Args:
tweet (str): The tweet to post.
tweet_id (int): The ID of the tweet to reply to.
Returns:
str: The tweet that was posted.
"""
replyID = plugin.api.update_status(
status=tweet_text,
in_reply_to_status_id=tweet_id,
auto_populate_reply_metadata=True,
)
return f"Success! Tweet: {replyID.text}"
def get_mentions() -> str | None:
"""Gets the most recent mention.
Args:
api (tweepy.API): The tweepy API object.
Returns:
str | None: The most recent mention.
"""
_tweets = plugin.api.mentions_timeline(tweet_mode="extended")
for tweet in _tweets:
return (
f"@{tweet.user.screen_name} Replied: {tweet.full_text}"
f" Tweet ID: {tweet.id}"
) # Returns most recent mention
def search_twitter_user(target_user: str, number_of_tweets: int) -> str:
"""Searches a user's tweets given a number of items to retrive and
returns a dataframe.
Args:
target_user (str): The user to search.
num_of_items (int): The number of items to retrieve.
api (tweepy.API): The tweepy API object.
Returns:
str: The dataframe containing the tweets.
"""
tweets = tweepy.Cursor(
plugin.api.user_timeline, screen_name=target_user, tweet_mode="extended"
).items(number_of_tweets)
columns = ["Time", "User", "ID", "Tweet"]
data = []
for tweet in tweets:
data.append(
[tweet.created_at, tweet.user.screen_name, tweet.id, tweet.full_text]
)
df = str(pd.DataFrame(data, columns=columns))
print(df)
return df # Prints a dataframe object containing the Time, User, ID, and Tweet
| src/autogpt_plugins/twitter/twitter.py | Significant-Gravitas-Auto-GPT-Plugins-3975893 | [
{
"filename": "src/autogpt_plugins/twitter/__init__.py",
"retrieved_chunk": " post_reply,\n post_tweet,\n search_twitter_user,\n )\n prompt.add_command(\n \"post_tweet\", \"Post Tweet\", {\"tweet_text\": \"<tweet_text>\"}, post_tweet\n )\n prompt.add_command(\n \"post_reply\",\n \"Post Twitter Reply\",",
"score": 30.546226979585782
},
{
"filename": "src/autogpt_plugins/bluesky/bluesky_plugin/bluesky_plugin.py",
"retrieved_chunk": "\"\"\"This module contains functions for interacting with the Bluesky API via atprototools.\"\"\"\nimport os\nimport pandas as pd\nfrom atproto import Client\ndef username_and_pwd_set() -> bool:\n return True if os.getenv(\"BLUESKY_USERNAME\") and os.getenv(\"BLUESKY_APP_PASSWORD\") else False\ndef post_message(text: str) -> str:\n \"\"\"Posts a message to Bluesky.\n Args:\n text (str): The message to post.",
"score": 23.39926192341716
},
{
"filename": "src/autogpt_plugins/bluesky/bluesky_plugin/bluesky_plugin.py",
"retrieved_chunk": " Returns:\n str: The message that was posted.\n \"\"\"\n bluesky_username = os.getenv(\"BLUESKY_USERNAME\")\n bluesky_app_password = os.getenv(\"BLUESKY_APP_PASSWORD\")\n client = Client()\n try:\n client.login(bluesky_username, bluesky_app_password)\n client.send_post(text=text)\n except Exception as e:",
"score": 20.973450324074733
},
{
"filename": "src/autogpt_plugins/random_values/random_values.py",
"retrieved_chunk": " self.plugin = plugin\n def random_number(self, min:int|str = 0, max:int|str = 65535, cnt:int|str = 1) -> str:\n \"\"\"\n Return a random integer between min and max\n Args:\n min (int): The minimum value\n max (int): The maximum value\n cnt (int): The number of random numbers to return\n Returns:\n str: a json array with 1 to \"count\" random numbers in the format",
"score": 20.541064296170205
},
{
"filename": "src/autogpt_plugins/bluesky/__init__.py",
"retrieved_chunk": " Args:\n response (str): The response.\n Returns:\n str: The resulting response.\n \"\"\"\n pass\n def can_handle_pre_command(self) -> bool:\n \"\"\"This method is called to check that the plugin can\n handle the pre_command method.\n Returns:",
"score": 20.03146467901917
}
] | python | api.update_status(status=tweet_text) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.