def translate(source_lang,
target_lang,
data_list: List[str] = Query(None),
special_tokens: List[str] = Query(None)):
'''
:param source_lang: source language [arb, eng, heb]
:param target_lang: target language [arb, eng, heb]
:param data_list: list[str]
:return: list[str]
'''
model_index = f"{source_lang}_{target_lang}"
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if model_index not in running_models.keys():
# need to init model
running_models[model_index] = Translator(source_lang=source_lang,
target_lang=target_lang,
special_tokens=special_tokens)
else: #model exists
if torch.cuda.is_available():
running_models[model_index].load_model_to_gpu()
running_models[model_index].to(device)
translation_df = running_models[model_index].translate(data_list)
api_logger.info(
f"returned value to client: {translation_df['tgt_text'].tolist()}")
_free_model(model_index)
return translation_df["tgt_text"].tolist()
def wrap(*args, **kwargs):
time1 = time.time()
ret = f(*args, **kwargs)
time2 = time.time()
api_logger.info('{:s} function took {:.3f} ms'.format(
f.__name__, (time2 - time1) * 1000.0))
return ret
async def send_file_block(server_id, file_path, piece):
try:
buffer = pickle.dumps(piece)
if server_id == settings.server_id:
await write_file_block_in_fs(file_path, buffer)
logger.info('%s: sendblock %d to server %d', file_path, piece.piece_id, server_id)
return True
else:
port = settings.base_port + server_id
url = 'http://%s:%d/writeblock/%s' % (settings.host, port, file_path)
headers = {
'content-type': 'application/octet-stream'
}
session = get_session()
async with session.post(url, data=buffer, headers=headers) as resp:
resp: aiohttp.ClientResponse
if resp.status == 200:
logger.info('%s: sendblock %d to server %d', file_path, piece.piece_id, server_id)
return True
else:
raise Exception(resp)
except Exception as e:
logger.error('%s failed: sendblock %d to server %d', file_path, piece.piece_id, server_id)
logger.exception(e)
return False
async def write_file_block_in_fs(file_path, buffer):
async with write_file_block_in_fs_lock:
filename = get_filename(file_path)
logger.info('%s: writeblock into server %d', file_path, settings.server_id)
file_path = os.path.join(settings.data_dir, filename)
async with aiofile.async_open(file_path, 'wb') as f:
await f.write(buffer)
def load_model_to_gpu(self):
if self.model is None:
torch.cuda.empty_cache()
self.model: AutoModelWithLMHead = AutoModelWithLMHead.from_pretrained(
self.trained_model_path)
api_logger.info(
f"loaded model {self.trained_model_path} to gpu memory.")
async def startup_event():
db = session_create()
if db.query(Department).count() == 0:
logger.info("Inserting Department Details, Previously None")
db.bulk_insert_mappings(
Department,
[{
"Code": code,
"Name": name
} for code, name in dept_dict.items()],
)
if db.query(BatchSchemeInfo).count() == 0:
logger.info("Inserting Batch Details, Previously None")
db.bulk_insert_mappings(
BatchSchemeInfo,
[{
"Batch": batch,
"Scheme": scheme
} for batch, scheme in batch_dict.items()],
)
db.commit()
db.close()
def __getLogger(cls, name: str) -> logging.Logger:
if name not in cls.__loggers:
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
if "pytest" in sys.modules:
print("logger..pytest")
return logger
path = pathlib.Path(f"../app/log/{name}")
logger.info(path.resolve())
# fileHandler = logging.handlers.TimedRotatingFileHandler(
# filename=path.resolve(),
# when='midnight',
# interval=1
# )
fileHandler2 = logging.handlers.RotatingFileHandler(
filename=path.resolve(), maxBytes=1000000, backupCount=100)
logger.addHandler(fileHandler2)
formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] %(message)s'
)
fileHandler2.setFormatter(formatter) # 핸들러에 로깅 포맷 할당
cls.__loggers[name] = logger
return cls.__loggers[name]
def info(self, func: str, msg: str = None) -> None:
if msg is None:
info = (f"cls: {self.cls}, msg: {func}")[:200]
self.logger.info(info)
return
info = (f"cls: {self.cls}, func: {func}, msg: {msg}")[:200]
self.logger.info(info)
logger.info(info)
def update_problem_config_by_archive(
file: UploadFile = File(...),
problem: models.Problem = Depends(parse_problem)
) -> StandardResponse[Empty]:
logger.info("problem config archive name: %s", file.filename)
problem_config = LakeFSProblemConfig(problem)
problem_config.upload_archive(file.filename, file.file)
return StandardResponse()
def register(self, obj: Any) -> None:
typeName = type(obj).__name__
key = None
if typeName == "type":
key = obj.__name__
else:
key = typeName
self.store[key] = obj
logger.info("Locator: " + key + " registered")
async def get_token(
websocket: WebSocket,
token: Any = Query(None),
) -> Optional[str]:
logger.info("TOKEN:" + str(token))
if token is None or not userService.check_token(token):
await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
return None
return token
async def commit_problem_config(
commit: schemas.ProblemConfigCommit = Body(...),
problem: models.Problem = Depends(parse_problem),
user: models.User = Depends(parse_user_from_auth),
) -> StandardResponse[schemas.ProblemConfig]:
result = await models.ProblemConfig.make_commit(problem=problem,
committer=user,
commit=commit)
logger.info("problem config commit: %s", result)
return StandardResponse(schemas.ProblemConfig.from_orm(result))
async def rebuild_redundancy(file: Raid6File, piece_map):
rebuild_flag = False
for server_id in piece_map:
if server_id < 0:
rebuild_flag = True
break
if not rebuild_flag:
return
logger.info('%s: rebuild redundancy', file.path)
await process_file(file, piece_map)
async def read_file_block(file_path: str):
try:
filename = get_filename(file_path)
logger.info('%s: readblock from server %d', file_path, settings.server_id)
file_path = os.path.join(settings.data_dir, filename)
# buffer = await read_file_block_from_fs(file_path)
# stream = io.BytesIO(buffer)
return FileResponse(file_path, media_type='application/octet-stream')
except Exception as e:
logger.exception(e)
raise HTTPException(400, str(e))
def _close_file(self):
"""Try to close file"""
try:
if self._file is not None and not self._file.closed:
self._file.close()
logger.info("WaveFileWriter - File closed: %s",
self._file_name)
except OSError:
logger.exception("WaveFileWriter - Failed to close file")
self.on_error(
"Engine: wave_file_writer - Message: Failed to close")
async def event_publisher():
i = 0
while True:
disconnected = await req.is_disconnected()
if disconnected:
_log.info(f"Disconnecting client {req.client}")
break
# yield dict(id=..., event=..., data=...)
i += 1
yield dict(data=i)
await asyncio.sleep(0.9)
_log.info(f"Disconnected from client {req.client}")
def __init__(self,
source_lang="heb",
target_lang="arb",
special_tokens=None):
'''
:param source_lang: source langauge to be translated from ["heb","arb","eng"]
:param target_lang: target langauge to be translated to ["heb","arb", "eng"]
:param max_cache_entries: maximum entrie
'''
self.source_lang = SPECIAL_CASE_TGT_MAP.get(source_lang, source_lang)
self.target_lang = SPECIAL_CASE_TGT_MAP.get(target_lang, target_lang)
self.special_tokens = special_tokens
with open("translator_config.json", "r") as fp:
languages_dict = json.load(fp)
try:
pretrained_model = languages_dict[self.source_lang][
self.target_lang]["model_name"]
special_token = languages_dict[self.source_lang][
self.target_lang]["special_tok"]
except:
raise NotImplementedError(
f"translation {self.source_lang}->{self.target_lang} not available"
)
trained_model_path = os.path.join("trained_models", pretrained_model)
self.special_tok = special_token
# loading models
self.tokenizer = AutoTokenizer.from_pretrained(trained_model_path)
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
api_logger.info(f"inference device: {self.device}")
self.trained_model_path = trained_model_path
self.model: AutoModelWithLMHead = AutoModelWithLMHead.from_pretrained(
self.trained_model_path)
if self.special_tokens is not None:
spec_dict = {"additional_special_tokens": self.special_tokens}
num_added = self.tokenizer.add_special_tokens(spec_dict)
api_logger.info(f"number tokens added: {num_added}")
self.model.resize_token_embeddings(len(
self.tokenizer)) # adding new tokens
self.model.to(self.device)
self.max_sequence_len = 512
self.translation_df = pd.DataFrame(columns=["src_text", "tgt_text"])
self.translation_cache = {}
def translate(self, x):
'''
translation function
:param x : [str, [str], pd.Series(str)] - data to be translated:
:return: returns df : pd.DataFrame with original and translated text
'''
cur_translation_df = pd.DataFrame(columns=["src_text", "tgt_text"])
if type(x) == list:
cur_translation_df["src_text"] = x
elif type(x) == str:
cur_translation_df["src_text"] = [x]
elif type(x) == pd.Series:
cur_translation_df["src_text"] = x
api_logger.info(cur_translation_df)
no_translations = []
after_translations = []
if len(cur_translation_df) > 0:
for src_text_itr in cur_translation_df["src_text"]:
translation_itr = self.translation_cache.get(
src_text_itr, None)
if translation_itr is None:
# need to translate
no_translations.append(src_text_itr)
# translated new
if len(no_translations) > 0:
processed_text_list_no_translation = [
self.preprocess(x) for x in no_translations
]
input_dict = self.tokenizer.prepare_translation_batch(
processed_text_list_no_translation)
# TODO fix the special tokens feature
# special_tokens_attention_mask = ~input_dict["input_ids"] >= torch.Tensor(
# self.tokenizer.additional_special_tokens_ids).min()
input_dict.to(self.device)
translated = self.model.generate(**input_dict)
tgt_text = [
self.tokenizer.decode(t, skip_special_tokens=True)
for t in translated
]
for src_text, translated_txt in zip(no_translations, tgt_text):
self.translation_cache[src_text] = translated_txt
# get translations from cache
for query_text in cur_translation_df["src_text"].tolist():
after_translations.append(self.translation_cache[query_text])
cur_translation_df["tgt_text"] = after_translations
return cur_translation_df
async def delete_file(file_path: str):
try:
logger.info('delete: %s', file_path)
start = time.time()
result = await remove_file(file_path)
deleted_count = sum(result)
return {
'success': deleted_count == settings.primary + settings.parity,
'result': result,
'delay': time.time() - start
}
except Exception as e:
logger.exception(e)
raise HTTPException(400, str(e))
async def event_publisher():
# The event publisher only conditionally emits items
has_data = True
while True:
disconnected = await req.is_disconnected()
if disconnected:
_log.info(f"Disconnecting client {req.client}")
break
# Simulate only sending one response
if has_data:
yield dict(data="u can haz the data")
has_data = False
await asyncio.sleep(0.9)
_log.info(f"Disconnected from client {req.client}")
def __init__(self, send_message):
"""Create wave file writer"""
super().__init__(send_message)
try:
WaveFileWriter.file_index = WaveFileWriter.file_index + 1
if WaveFileWriter.file_index > 99:
WaveFileWriter.file_index = 1
self._file_name = (
f"{settings.recordings_path}{WaveFileWriter.file_index}-{int(time.time())}.wav"
)
self._file = open(self._file_name, 'wb')
logger.info("WaveFileWriter - Created file: %s", self._file_name)
except OSError:
logger.exception("WaveFileWriter - Failed to create file")
self.on_error(
"Engine: wave_file_writer - Message: Failed to create file")
def cancelCrawling(self, data: dict, websocket: WebSocket) -> None:
dtoList = []
logger.info(str(data))
for market in data["market"]:
dto = StockRunCrawling(
**{
"driverAddr": "http://fin-carwling-webdriver:4444",
"market": market,
"startDateStr": data["startDate"],
"endDateStr": data["endDate"],
"taskId": data["taskId"],
"taskUniqueId": data["taskUniqueId"]
})
dtoList.append(dto)
for dto in dtoList:
self.stockService.cancelCrawling(dto)
async def write_file(file_path: str, file: UploadFile = File(...)):
try:
logger.info('write: %s', file_path)
buffer = await file.read()
file = generate_file(file_path, buffer)
piece_map = [-1] * (settings.primary + settings.parity)
result, delay = await process_file(file, piece_map)
received_count = sum(result)
return {
'success': received_count >= settings.primary,
'result': result,
'delay': delay
}
except Exception as e:
logger.exception(e)
raise HTTPException(400, str(e))
async def delete_file_block_in_fs(file_path, timestamp):
async with write_file_block_in_fs_lock:
filename = get_filename(file_path)
new_file_path = os.path.join(settings.data_dir, filename)
delete_flag = True
try:
async with aiofile.async_open(new_file_path, 'rb') as f:
piece = pickle.loads(await f.read())
if piece.timestamp >= timestamp:
delete_flag = False
except Exception as e:
logger.exception(e)
pass
logger.info('%s: deleteblock from server %d, flag=%d', file_path, settings.server_id, delete_flag)
if delete_flag:
os.remove(new_file_path)
return delete_flag
async def delete_file_block(server_id, file_path, timestamp):
try:
if server_id == settings.server_id:
return await delete_file_block_in_fs(file_path, timestamp)
else:
port = settings.base_port + server_id
url = 'http://%s:%d/deleteblock/%s?timestamp=%d' % (settings.host, port, file_path, timestamp)
session = get_session()
async with session.get(url) as resp:
resp: aiohttp.ClientResponse
if resp.status == 200:
data = await resp.json()
logger.info(data)
if data['result'] is True:
return True
else:
raise Exception(resp)
except Exception as e:
pass
# logger.error('%s failed: receiveblock from server %d', file_path, server_id)
logger.exception(e)
return False
async def receive_file_block(server_id, file_path):
try:
if server_id == settings.server_id:
buffer = await read_file_block_from_fs(file_path)
piece = pickle.loads(buffer)
logger.info('%s: receiveblock %d from server %d', file_path, piece.piece_id, server_id)
return piece
else:
port = settings.base_port + server_id
url = 'http://%s:%d/readblock/%s' % (settings.host, port, file_path)
session = get_session()
async with session.get(url) as resp:
resp: aiohttp.ClientResponse
if resp.status == 200:
buffer = await resp.read()
piece = pickle.loads(buffer)
logger.info('%s: receiveblock %d from server %d', file_path, piece.piece_id, server_id)
return piece
else:
raise Exception(resp)
except Exception as e:
logger.error('%s failed: receiveblock from server %d', file_path, server_id)
logger.exception(e)
return None
async def event_publisher():
i = 0
try:
while True:
disconnected = await req.is_disconnected()
if disconnected:
_log.info(f"Disconnecting client {req.client}")
break
# yield dict(id=..., event=..., data=...)
i += 1
yield dict(data=i)
await asyncio.sleep(0.9)
_log.info(f"Disconnected from client {req.client}")
except asyncio.CancelledError as e:
_log.info(f"Disconnected from client (via refresh/close) {req.client}")
# Do any other cleanup, if any
raise e
]
app = FastAPI()
app.include_router(socketRouter)
app.include_router(userRouter)
app.include_router(stockRouter)
app.include_router(factorRouter)
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
logger.info("initiate app2")
# def my_excepthook(type, value, traceback):
# logger.error('Unhandled error:', str(type), str(value), str(traceback))
# sys.excepthook = my_excepthook
@app.get("/hello")
async def hello() -> dict:
return {"message": "Hello World"}
loop = None
def free_model_mem(self):
del self.model
self.model = None
torch.cuda.empty_cache()
api_logger.info(
f"freed model {self.trained_model_path} from gpu memory.")
async def read_file_block_from_fs(file_path):
filename = get_filename(file_path)
logger.info('%s: readblock from server %d', file_path, settings.server_id)
file_path = os.path.join(settings.data_dir, filename)
async with aiofile.async_open(file_path, 'rb') as f:
return await f.read()
