Exemple #1
0
    async def process(client: SocketModeClient, req: SocketModeRequest):
        db_session = SessionLocal()
        background_tasks = BackgroundTasks()

        if req.type == "events_api":
            response = await handle_slack_event(
                db_session=db_session,
                client=client.web_client,
                request=req.payload,
                background_tasks=background_tasks,
            )

        if req.type == "slash_commands":
            response = await handle_slack_command(
                db_session=db_session,
                client=client.web_client,
                request=req.payload,
                background_tasks=background_tasks,
            )

        if req.type == "interactive":
            response = await handle_slack_action(
                db_session=db_session,
                client=client.web_client,
                request=req.payload,
                background_tasks=background_tasks,
            )

        response = SocketModeResponse(envelope_id=req.envelope_id, payload=response)
        await client.send_socket_mode_response(response)

        # run the background tasks
        await background_tasks()
Exemple #2
0
def test_send(session, bad_user, event):
    background_task = BackgroundTasks()
    assert not send(session=session,
                    event_used=1,
                    user_to_send=1,
                    title="Test",
                    background_tasks=background_task)
Exemple #3
0
 def __init__(self) -> None:
     """
     Crud instances of the collections needed.
     """
     self.crud = CRUD(organizations_collection)
     self.users = CRUD(users_collection)
     self.events = CRUD(events_collection)
     self.backgroud_task = BackgroundTasks()
async def _predict_label(
    data: Data,
    job_id: str,
    background_tasks: BackgroundTasks = BackgroundTasks()
) -> Dict[str, Dict[str, float]]:
    label_proba = await __async_predict_label(data)
    store_data_job._save_data_job(data, job_id, background_tasks, False)
    return {'prediction': label_proba, 'job_id': job_id}
Exemple #5
0
async def _predict_async_post(
    data: Data,
    job_id: str,
    background_tasks: BackgroundTasks = BackgroundTasks()
) -> Dict[str, List[float]]:
    image = base64.b64decode(str(data.image_data))
    io_bytes = io.BytesIO(image)
    data.image_data = Image.open(io_bytes)
    store_data_job._save_data_job(data, job_id, background_tasks, True)
    return {'job_id': job_id}
Exemple #6
0
    async def _handle_request(self, request: Request) -> Response:
        # route GET requests to the IDE
        if request.method == "GET" and "text/html" in request.headers.get("Accept", ""):
            # read the GraphiQL playground html and serve it as content
            graphiql = pathlib.Path(__file__).parent / "graphiql.html"
            raw_html = None

            with open(graphiql.absolute(), "r") as f:
                raw_html = f.read()

            return HTMLResponse(raw_html)
        # route POST requests to the graphql executor
        elif request.method == "POST":
            content_type = request.headers.get("Content-Type", "")

            # parse graphql according to content type
            if "application/json" in content_type:
                data = await request.json()
            else:
                return PlainTextResponse(
                    "Unsupported Media Type",
                    status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
                )
        else:
            return PlainTextResponse(
                "Method Not Allowed", status_code=status.HTTP_405_METHOD_NOT_ALLOWED
            )

        # attempt to pull final query and vars
        try:
            query = data["query"]
            variables = data.get("variables")
        except KeyError:
            return PlainTextResponse(
                "No GraphQL query found in the request",
                status_code=status.HTTP_400_BAD_REQUEST,
            )

        # construct foundation fastapi context
        background = BackgroundTasks()
        context = {"request": request, "background": background}
        result = await self._execute_graphql(query, variables, context)

        # parse graphql result
        response = {}
        if not result.invalid:
            response["data"] = result.data
        if result.errors:
            response["errors"] = [format_error(e) for e in result.errors]

        status_code = (
            status.HTTP_400_BAD_REQUEST if result.errors else status.HTTP_200_OK
        )

        return ORJSONResponse(response, status_code=status_code, background=background)
Exemple #7
0
async def _predict_label(
    data: Data,
    job_id: str,
    background_tasks: BackgroundTasks = BackgroundTasks()
) -> Dict[str, List[float]]:
    image = base64.b64decode(str(data.image_data))
    io_bytes = io.BytesIO(image)
    data.image_data = Image.open(io_bytes)
    label_proba = await __async_predict_label(data)
    store_data_job._save_data_job(data, job_id, background_tasks, False)
    return {'prediction': label_proba, 'job_id': job_id}
Exemple #8
0
async def post_message_async(
    content: ItemInParse,
    # user: User = Depends(get_current_user_authorizer()),
):

    if not content.message:
        raise HTTPException(
            status_code=HTTP_400_BAD_REQUEST,
            detail=f"Couldn't find the message: {content}",
        )

    backgroundtask = BackgroundTasks()
    backgroundtask.add_task(dummy_background_task, content.message)

    return JSONResponse(
        {"status": "Starting dummy background task"},
        background=backgroundtask,
    )
Exemple #9
0
async def upload_py(file: UploadFile = File(...),
                    message_format: str = None,
                    background_tasks: BackgroundTasks = BackgroundTasks()):

    message = ''
    msg_format = 'text'
    if message_format.lower() == 'json':
        msg_format = 'json'

    log.info(
        f'{datetime.datetime.now().strftime("%Y-%m-%d-%H:%M.%S")}: '
        f'Запрос на выполнение статического анализа файла "{file.filename}" '
        f'с выводом отчета в формате {msg_format}')

    if file.filename[-3:] != '.py':
        message = f'Получен файл "{file.filename}" с неправилным расширением. Необходим файл с расширением .py'
        log.warning(
            f'{datetime.datetime.now().strftime("%Y-%m-%d-%H:%M.%S")}: {message}'
        )
    else:
        if not os.path.exists(today_folder):
            os.mkdir(today_folder)

        file_name = f'{file.filename[:-3]}_{datetime.datetime.now().strftime("%H-%M-%S")}'
        file_path = os.path.join(today_folder, f'{file_name}.py')
        try:
            with open(file_path, 'wb') as buffer:
                shutil.copyfileobj(file.file, buffer)
        except Exception:
            message = f'Ошибка сервера'
            log.exception(
                f'{datetime.datetime.now().strftime("%Y-%m-%d-%H:%M.%S")}: {message}: {Exception}'
            )
        else:
            message = f'Файл "{file.filename}" успешно загружен, ' \
                      f'сохранен под названием "{file_name}.py" ' \
                      f'и начaлся статический анализ с использованием pylint'
            log.info(
                f'{datetime.datetime.now().strftime("%Y-%m-%d-%H:%M.%S")}: {message}'
            )
            background_tasks.add_task(pylint_analyse, file_path, file_name,
                                      msg_format)
    return {f'message': message}
Exemple #10
0
    async def process(client: SocketModeClient, req: SocketModeRequest):
        background_tasks = BackgroundTasks()

        if req.type == "events_api":
            response = await handle_slack_event(
                config=config,
                client=client.web_client,
                event=EventEnvelope(**req.payload),
                background_tasks=background_tasks,
            )

        if req.type == "slash_commands":
            response = await handle_slack_command(
                config=config,
                client=client.web_client,
                request=req.payload,
                background_tasks=background_tasks,
            )

        if req.type == "interactive":
            if req.payload["type"] == "block_suggestion":
                response = await handle_slack_menu(
                    config=config,
                    client=client.web_client,
                    request=req.payload,
                )

            else:
                response = await handle_slack_action(
                    config=config,
                    client=client.web_client,
                    request=req.payload,
                    background_tasks=background_tasks,
                )

        response = SocketModeResponse(envelope_id=req.envelope_id,
                                      payload=response)
        await client.send_socket_mode_response(response)

        # run the background tasks
        await background_tasks()
Exemple #11
0
async def run_ranking(ranker: Ranker):
    background_tasks = BackgroundTasks()
    background_tasks.add_task(rank_service.rank_by_session, ranker)
    response = JSONResponse(status_code=200, content="Ranking is running", background=background_tasks)
    return response
Exemple #12
0
 def startup_event():
     background_tasks = BackgroundTasks()
     background_tasks.add_task(self.end)
     return True
async def predict_label(data: Data,
                        background_tasks: BackgroundTasks = BackgroundTasks()):
    job_id = data.job_id if data.job_id is not None else get_job_id()
    return await _predict._predict_label(data, job_id, background_tasks)
Exemple #14
0
def background_tasks():
    bg_tasks = BackgroundTasks()
    return bg_tasks
Exemple #15
0
import pytest
import json
from PIL import Image
from typing import List, Tuple, Any
from fastapi import BackgroundTasks

from src.constants import PLATFORM_ENUM, CONSTANTS
from src.jobs import store_data_job
import src.jobs
from src.app.ml.base_predictor import BaseData, BaseDataInterface

test_job_id = '550e8400-e29b-41d4-a716-446655440000_0'
test_uuid = '550e8400-e29b-41d4-a716-446655440000'
mock_image = Image.open('src/app/ml/data/good_cat.jpg')
labels = ['a', 'b', 'c']
mock_BackgroundTasks = BackgroundTasks()


class MockData(BaseData):
    data: List[List[int]] = [[5.1, 3.5, 1.4, 0.2]]
    test_data: List[List[int]] = [[5.1, 3.5, 1.4, 0.2]]
    labels: List[str] = labels


class MockDataImage(BaseData):
    image_data: Any = mock_image
    data: List[List[int]] = [[5.1, 3.5, 1.4, 0.2]]
    test_data: List[List[int]] = [[5.1, 3.5, 1.4, 0.2]]
    labels: List[str] = labels

Exemple #16
0
async def create_ihou(info: dict):
    try:
        await IHou.objects.get(title=info['title'])
    except orm.exceptions.NoMatch as e:
        document = await IHou.objects.create(**info)
        BackgroundTasks().add_task(insert_values(document.__dict__))
Exemple #17
0
async def predict(data: Data,
                  background_tasks: BackgroundTasks = BackgroundTasks()):
    job_id = data.job_id if data.job_id is not None else get_job_id()
    result = await _predict_image._predict(data, job_id, background_tasks)
    return result
Exemple #18
0
async def predict(data: Data,
                  background_tasks: BackgroundTasks = BackgroundTasks()):
    job_id = data.job_id if data.job_id is not None else get_job_id()
    return await _predict_ab_test._predict(data, job_id, background_tasks,
                                           AB_TEST_GROUP)
Exemple #19
0
def test_send_mail_bad_invitation_internal(client, configured_smtpd,
                                           sender_name, recipient_name,
                                           recipient_mail):
    background_task = BackgroundTasks()
    assert not send_email_invitation(sender_name, recipient_name,
                                     recipient_mail, background_task)
Exemple #20
0
def test_send_mail_good_file_internal(client, configured_smtpd):
    background_task = BackgroundTasks()
    assert send_email_file(__file__, "*****@*****.**", background_task)
Exemple #21
0
def test_send_mail_bad_file_internal(client, configured_smtpd, recipient_mail,
                                     file_path):
    background_task = BackgroundTasks()
    assert not send_email_file(file_path, recipient_mail, background_task)