diff --git a/Dockerfile.old b/Dockerfile.old
deleted file mode 100644
index b00f3d65e8dddefb9ded18e07ec4b8c9eebd3dcc..0000000000000000000000000000000000000000
--- a/Dockerfile.old
+++ /dev/null
@@ -1,37 +0,0 @@
-FROM python:3.10-bullseye as backend
-
-ENV JASS_DATA_DIR '/data'
-ENV JASS_PROJECTS_DIR '/projects'
-
-EXPOSE 8080
-
-CMD ["uvicorn", "jass.server:app", "--host", "0.0.0.0", "--port", "8080"]
-
-RUN addgroup --gid 1000 kiwi \
- && adduser --disabled-password --gecos '' --uid 1000 --gid 1000 kiwi \
- && apt-get update \
- && apt-get install -y \
- nano \
- wget \
- rsync \
- && rm -rf /var/lib/apt/lists/* \
- && pip install --upgrade pip setuptools \
- && mkdir /code \
- && mkdir ${JASS_DATA_DIR} \
- && chown kiwi:kiwi ${JASS_DATA_DIR} \
- && mkdir ${JASS_PROJECTS_DIR} \
- && chown kiwi:kiwi ${JASS_PROJECTS_DIR}
-WORKDIR /code
-
-COPY requirements*.txt /code/
-RUN pip install -r requirements.txt \
- && pip3 install -U watchdog[watchmedo]
-
-COPY ./*-entrypoint.sh /
-RUN chmod a+x /*-entrypoint.sh
-ENTRYPOINT ["/docker-entrypoint.sh"]
-
-COPY . /code/
-RUN pip install -e .
-
-USER kiwi
diff --git a/docker-compose.test.yaml.old b/docker-compose.test.yaml.old
deleted file mode 100644
index 8c30f7691ce6711638fcb243144b7bca8b13d7ca..0000000000000000000000000000000000000000
--- a/docker-compose.test.yaml.old
+++ /dev/null
@@ -1,8 +0,0 @@
-version: '3.4'
-services:
- celery:
- volumes:
- - ./jass/test/data_real:/data
- back:
- volumes:
- - ./jass/test/data_real:/data
\ No newline at end of file
diff --git a/docker-compose.yaml.old b/docker-compose.yaml.old
deleted file mode 100644
index 69f2b02235cd7d6dcda38b205af546fa3d3ddccd..0000000000000000000000000000000000000000
--- a/docker-compose.yaml.old
+++ /dev/null
@@ -1,67 +0,0 @@
-version: '3.4'
-services:
- rabbitmq:
- image: rabbitmq:3-alpine
- healthcheck:
- test: ['CMD', 'rabbitmqctl', 'status']
- interval: 30s
- timeout: 15s
- retries: 3
- volumes:
- - ./chart/rabbitmq.conf:/etc/rabbitmq/conf.d/20-jass.conf
- ports:
- - '5672:5672'
- celery:
- build:
- context: .
- image: jass
- # dirty command below waits a little bit for rabbitmq to be
- # up and running before starting celery
- command: ['/bin/sh', '-c', 'sleep 10 && watchmedo auto-restart --directory=/code --pattern=*.py --recursive -- celery -A jass worker --concurrency=1 --max-tasks-per-child=1']
- environment:
- #LC_ALL: en_US.utf-8
- RABBITMQ_HOST: 'rabbitmq'
- WAIT_FOR_DATA_DIR_READY: 1
- volumes:
- - ./projects:/projects
- - ./data:/data
- - ./jass:/code/jass
- depends_on:
- - rabbitmq
- restart: on-failure
- back:
- build:
- context: .
- command: ['watchmedo', 'auto-restart', '--directory=/code', '--pattern=*.py', '--recursive', '--', 'uvicorn', 'jass.server:app', '--host', '0.0.0.0', '--reload', '--port', '8080']
- environment:
- RABBITMQ_HOST: 'rabbitmq'
- volumes:
- - ./projects:/projects
- - ./data:/data
- - ./jass:/code/jass
- ports:
- - '8080:8080'
- depends_on:
- - rabbitmq
- - celery
- front:
- build:
- context: client
- target: client-base-container
- command: /bin/sh -c "yarn install && yarn dev"
- environment:
- HOST: 0.0.0.0
- NODE_ENV: development
-# API_URL: http://172.19.0.1:8000/api
- volumes:
- - ./client:/client
- ports:
- - '3000:3000'
- front-static:
- build:
- context: client
- target: client-static-serve
-# args:
-# API_URL: http://0.0.0.0:8000/api
- ports:
- - '3001:8080'
diff --git a/docker-entrypoint.sh.old b/docker-entrypoint.sh.old
deleted file mode 100644
index a0aa4ac3c8fca432539f876b88042c73ff2e626c..0000000000000000000000000000000000000000
--- a/docker-entrypoint.sh.old
+++ /dev/null
@@ -1,45 +0,0 @@
-#!/bin/bash
-
-function msg_info {
- echo -e "\033[1;32m$1\033[0m"
-}
-
-function msg_warning {
- echo -e "\033[1;33m$1\033[0m"
-}
-
-function msg_error {
- echo -e "\033[1;31m$1\033[0m"
-}
-
-cd /code
-
-if [ "$1" == "hold_on" ]; then
- msg_info "holding on util you delete /tmp/hold_on"
- touch /tmp/hold_on
- while [ -e "/tmp/hold_on" ]; do
- sleep 1 ;
- echo "holding on" ;
- done
-fi
-
-#if [ "${WAIT_FOR_DATA_DIR_READY}" == "1" ]; then
-# while [ ! -f ${DATA_DIR_READY} ]; do
-# msg_info "Waiting for data dir ot flagged ready with ${DATA_DIR_READY}"
-# sleep 5
-# done
-#else
-# msg_info "Copying file from /code/data to ${JASS_DATA_DIR}"
-# rsync -a /code/data/ ${JASS_DATA_DIR}/
-# export INIT_TABLE_PATH="${JASS_DATA_DIR}/initTable.hdf5"
-# if [ ! -f ${INIT_TABLE_PATH} ]; then
-# msg_info "$INIT_TABLE_PATH missing, downloading it from $INIT_TABLE_URL"
-# wget "${INIT_TABLE_URL}" --output-document=${INIT_TABLE_PATH}
-# else
-# msg_info "$INIT_TABLE_PATH found"
-# fi
-# touch ${DATA_DIR_READY}
-#fi
-
-
-exec "$@"
diff --git a/jass/celeryconfig.py.old b/jass/celeryconfig.py.old
deleted file mode 100644
index 4922de85e5d60e4d83e05209da88e9c6355402c1..0000000000000000000000000000000000000000
--- a/jass/celeryconfig.py.old
+++ /dev/null
@@ -1,26 +0,0 @@
-import os
-
-## Broker settings.
-# broker_url = os.getenv("JASS_RABBITMQ_URL", "amqp://guest:guest@localhost:5672//")
-from jass.config import config
-
-broker_url = "amqp://%(user)s:%(pwd)s@%(host)s:%(port)s//" % dict(
- user=os.getenv('RABBITMQ_USER', 'guest'),
- pwd=os.getenv('RABBITMQ_PASSWORD', 'guest'),
- host=os.getenv('RABBITMQ_HOST', 'localhost'),
- port=os.getenv('RABBITMQ_PORT', '5672'),
-)
-
-## Broker settings.
-# result_backend = os.getenv('JASS_RABBITMQ_URL','amqp://guest2:guest@localhost:5672//')
-# result_backend = "rpc://"
-result_backend = f'file://{config["CELERY_RESULTS_BACKEND_DIR"]}' # if rpc become not a solution
-# List of modules to import when the Celery worker starts.
-# imports = ('myapp.tasks',)
-
-## Using the database to store task state and results.
-# result_backend = 'db+sqlite:///results.db'
-
-# task_annotations = {'tasks.add': {'rate_limit': '10/s'}}
-# task_track_started = True
-task_acks_late = True # needed as worker can be killed by k8s when consuming to much RAM
diff --git a/jass/server.py.old b/jass/server.py.old
deleted file mode 100644
index d5ed5f36ea9fb89d6eb34ba97ae351ca4b92aa19..0000000000000000000000000000000000000000
--- a/jass/server.py.old
+++ /dev/null
@@ -1,358 +0,0 @@
-#!/usr/bin/env python3
-import logging
-import os
-import shutil
-import traceback
-from json import JSONDecodeError
-from pathlib import Path
-from typing import List
-
-from starlette.responses import RedirectResponse, JSONResponse
-from tables import HDF5ExtError
-
-from jass import util
-from jass.config import config
-from jass.models.phenotype import Phenotype, get_available_phenotypes, PhenotypeIdList, InitTableNameModel
-from jass.models.inittable import get_inittable_meta, valideInitTableNamePattern
-from jass.models.project import GlobalProject, load_project as project__load_project
-from jass.tasks import create_project, run_project_analysis_if_needed, get_queue_status
-
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import Response, FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-
-app = FastAPI()
-
-app.add_middleware(
- CORSMiddleware,
- allow_origins=["*"],
- allow_methods=["*"],
- allow_headers=["*"],
-)
-
-if os.path.exists('client/dist'):
- app.mount("/webui", util.SinglePageApplication(directory=Path('client/dist')), name="SPA")
-else:
- logging.info("/webui cannot be served as client/dist is missing, please build the client.")
-
-
-def load_project(project_id, *args, **kargs):
- try:
- return project__load_project(project_id=project_id, *args, **kargs)
- except FileNotFoundError:
- raise HTTPException(status_code=404, detail="Project not found")
- except JSONDecodeError as e:
- print(f"Project {project_id} has a corrupted meta.json ({str(e)}), removing it.")
- shutil.rmtree(GlobalProject.get_folder_path_from_id(project_id))
- raise HTTPException(status_code=404, detail="Project invalid, and removed")
-
-
-@app.get("/")
-async def read_index():
- return RedirectResponse(url="/webui/")
-
-
-@app.get("/api/tables", response_model=List[str])
-def inittable_list():
- """List initTables"""
- for filename in os.listdir(config["DATA_DIR"]):
- if (
- filename.endswith(".hdf5")
- and "worktable" not in filename.lower()
- and valideInitTableNamePattern.match(filename)
- ):
- yield filename
-
-
-@app.post("/api/phenotypes", response_model=List[Phenotype])
-def phenotypes_list(init_table_name: InitTableNameModel):
- """List phenotypes"""
- try:
- return get_available_phenotypes(init_table_name.get_init_table_path())
- except FileNotFoundError as e: # initTable does not exists
- raise HTTPException(status_code=404, detail=str(e))
-
-@app.post("/api/initmeta")
-def inittable_meta(init_table_name: InitTableNameModel):
- """Number of phenotype and SNPs"""
- return get_inittable_meta(init_table_name.get_init_table_path())
-
-
-@app.post("/api/projects", response_model=GlobalProject)
-def project_create(phenotype_id_list: PhenotypeIdList):
- return create_project(
- phenotype_id_list.phenotypeID,
- init_table_name=phenotype_id_list.initTableName,
- )
-
-
-@app.get("/api/projects/{project_id}", response_model=GlobalProject)
-def project_detail(project_id: str):
- project = load_project(project_id=project_id)
- run_project_analysis_if_needed(project)
- return project
-
-
-@app.get("/api/projects/{project_id}/progress", response_model = int )
-def project_detail(project_id: str):
- return load_project(project_id=project_id).progress
-
-
-@app.get("/api/projects/{project_id}/unload", response_model=bool)
-def project_detail(project_id: str):
- return load_project(project_id=project_id, flag_as_visited=False).delete_large_files()
-
-
-@app.get("/api/projects/{project_id}/summary")
-def project_detail(project_id: str):
- return load_project(project_id=project_id).get_project_summary_statistics()
-
-
-@app.get("/api/projects/{project_id}/gencov")
-def project_gencov_view(project_id: str):
- try:
- return util.JSONNumpyResponse(load_project(project_id=project_id).get_project_gencov())
- except ValueError as e: # NaN in values
- raise HTTPException(status_code=500, detail=str(e))
- except HDF5ExtError as e: # file corrupted
- raise HTTPException(status_code=500, detail=str(e))
- except Exception as e: # anything else
- traceback.print_exc()
- raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/api/projects/{project_id}/metadata")
-def project_metadata(project_id: str):
- return FileResponse(load_project(project_id=project_id).get_metadata_file_path())
-
-
-@app.get("/api/projects/{project_id}/globalmanhattan")
-def project_get_manhattan(project_id: str):
- return FileResponse(
- load_project(project_id=project_id).get_global_manhattan_plot_path(),
- media_type="image/png",
- )
-
-
-@app.get("/api/projects/{project_id}/quadrant")
-def project_get_quadrant(project_id: str):
- return FileResponse(
- load_project(project_id=project_id).get_quadrant_plot_path(),
- media_type="image/png",
- )
-
-
-@app.get("/api/projects/{project_id}/qqplot")
-def project_get_qq_plot(project_id: str):
- return FileResponse(
- load_project(project_id=project_id).get_qq_plot_path(),
- media_type="image/png",
- )
-
-
-@app.get("/api/projects/{project_id}/genome_full")
-def get_full_sumstat(project_id: str):
- project = load_project(project_id=project_id)
- if not os.path.exists(project.get_csv_path()):
- print("CREATING CSV FILE")
- project.create_csv_file()
- print("CREATED CSV FILE")
- return FileResponse(
- project.get_csv_path(),
- filename=f"genome_full_{project_id}.csv",
- media_type="text/csv",
- )
-
-
-@app.get("/api/projects/{project_id}/genome")
-def get_data_manhattan(project_id: str):
- return Response(
- content=load_project(project_id=project_id).get_project_genomedata(),
- media_type="text/csv",
- headers={"content-disposition": f"attachment; filename=genome_{project_id}.csv"},
- )
-
-
-@app.get("/api/projects/{project_id}/heatmap/{selected_chr}/{selected_region}")
-def get_heatmap(project_id: str, selected_chr: str, selected_region: str):
- print("CHR")
- print(selected_chr)
- print("Region")
- print(selected_region)
- return Response(
- load_project(project_id=project_id).get_project_local_heatmap_data(
- chromosome=selected_chr,
- region=selected_region,
- ),
- media_type="text/csv; charset=utf-8",
- )
-
-
-@app.get("/api/projects/{project_id}/manhattan/{selected_chr}/{selected_region}")
-def get_manhattan(project_id: str, selected_chr: str, selected_region: str):
- return Response(
- load_project(project_id=project_id).get_project_local_manhattan_data(
- chromosome=selected_chr,
- region=selected_region,
- ),
- media_type="text/csv; charset=utf-8",
- )
-
-
-@app.get("/api/queue_status")
-def queue_status():
- return JSONResponse(get_queue_status())
-
-
-
-
-# @blp_inittable.route("")
-# class InitMetaMethodView(MethodView):
-# @blp_inittable.response(200, InittableMetaSchema())
-# def get(self):
-# """Number of phenotype and SNPs"""
-# return get_inittable_meta(os.path.join(config["DATA_DIR"], "initTable.hdf5"))
-
-# @blp_projects.route("")
-# class ProjectCreateMethodView(MethodView):
-# @blp_projects.arguments(ProjectParamsSchema(), location="form")
-# @blp_projects.response(200, ProjectSchema())
-# def post(self, parameters):
-# """List projects"""
-# phenotype_ids = [
-# phenotype_id
-# for ids_with_commas in parameters["phenotypeID"]
-# for phenotype_id in ids_with_commas.split(",")
-# ]
-# phenotypes = list(filter(lambda d: d.id in phenotype_ids, get_phenotypes()))
-# return create_project([p.id for p in phenotypes], get_phenotypes())
-
-
-# @blp_local_projects.route("")
-# class LocalProjectCreateMethodView(MethodView):
-# @blp_projects.arguments(LocalProjectParamsSchema(), location="form")
-# @blp_projects.response(200, ProjectSchema())
-# def post(self, parameters):
-# """List projects"""
-# phenotype_ids = [
-# phenotype_id
-# for ids_with_commas in parameters["phenotypeID"]
-# for phenotype_id in ids_with_commas.split(",")
-# ]
-# phenotypes = list(filter(lambda d: d.id in phenotype_ids, get_phenotypes()))
-# return create_project(
-# [p.id for p in phenotypes],
-# get_phenotypes(),
-# str(parameters["chromosome"]),
-# str(parameters["start"]),
-# str(parameters["end"]),
-# )
-
-
-# @blp_projects.route("/<project_id>")
-# class ProjectDetailMethodView(MethodView):
-# @blp_projects.response(200, ProjectSchema())
-# def get(self, project_id):
-# return load_project(project_id=project_id)
-
-
-# @blp_projects.route("/<project_id>/csv_status")
-# class ProjectCSVStatusMethodView(MethodView):
-# def get(self, project_id):
-# return load_project(project_id=project_id).get_csv_file_generation()
-
-
-
-
-
-
-
-
-
-
-
-
-# @blp_projects.route("/<project_id>/zoom_manhattan")
-# class ProjectZoomManhattanMethodView(MethodView):
-# def get(self, project_id):
-# try:
-# return (
-# load_project(project_id=project_id).get_project_local_manhattan_data(),
-# 200,
-# {"Content-Type": "text/plain; charset=utf-8"},
-# )
-# except FileNotFoundError:
-# status = Project(id=project_id).status
-# # if status == Project.DOES_NOT_EXIST:
-# # return (
-# # f"project {project_id} does not exist",
-# # 404,
-# # {"Content-Type": "text/plain; charset=utf-8"},
-# # )
-# # elif status["worktable"] == Project.CREATING:
-# # return (
-# # "data not ready yet",
-# # 202,
-# # {"Content-Type": "text/plain; charset=utf-8"},
-# # )
-# # else:
-# # abort(500)
-
-
-
-# @blp_projects.route("/<project_id>/zoomplot")
-# class ProjectZoomPlotMethodView(MethodView):
-# def get(self, project_id):
-# try:
-# return send_file(
-# load_project(project_id=project_id).get_zoom_plot_path(), mimetype="image/png"
-# )
-# except FileNotFoundError:
-# status = load_project(project_id=project_id).status
-# # if status == Project.DOES_NOT_EXIST:
-# # return (
-# # f"project {project_id} does not exist",
-# # 404,
-# # {"Content-Type": "text/plain; charset=utf-8"},
-# # )
-# # elif status["worktable"] == Project.CREATING:
-# # return (
-# # "data not ready yet",
-# # 202,
-# # {"Content-Type": "text/plain; charset=utf-8"},
-# # )
-# # else:
-# # abort(500)
-
-
-
-
-
-# class JassApp(Flask):
-# """
-# JassApp builds the JASS Flask application
-# """
-
-# def __init__(self):
-# self.flask_app = Flask(__name__, static_url_path="", static_folder="static")
-# self.flask_app.config["API_TITLE"] = "JASS API"
-# self.flask_app.config["API_VERSION"] = "v2.0"
-# self.flask_app.config["OPENAPI_VERSION"] = "3.0.2"
-# self.flask_app.route("/")(self.redirect_to_index)
-# self.api = Api(self.flask_app)
-
-# def create_app(self):
-# return self.flask_app
-
-# def redirect_to_index(self):
-# return redirect("index.html")
-
-# def register_api_blueprint(self, blp):
-# self.api.register_blueprint(blp, url_prefix=f"/api/{blp.url_prefix}")
-
-
-# jass_app = JassApp()
-# jass_app.register_api_blueprint(blp_phenotypes)
-# jass_app.register_api_blueprint(blp_projects)
-# jass_app.register_api_blueprint(blp_local_projects)
-# jass_app.register_api_blueprint(blp_inittable)
diff --git a/jass/tasks.py.old b/jass/tasks.py.old
deleted file mode 100644
index 82e9b9d9c014f7468726cfb268e376099ff9b3cb..0000000000000000000000000000000000000000
--- a/jass/tasks.py.old
+++ /dev/null
@@ -1,191 +0,0 @@
-import os
-import sys
-import traceback
-from typing import List, Dict
-
-from celery import Celery, group, chain
-from fastapi import HTTPException
-from flask import Flask
-
-import jass.models.project
-from jass.models.project import GlobalProject, Project, ensure_space_in_project_dir
-
-from jass.models.phenotype import Phenotype, get_available_phenotypes
-from jass.config import config
-
-
-def make_celery(app):
- celery = Celery()
- if "CELERY_CONFIG_MODULE" in os.environ:
- celery.config_from_envvar("CELERY_CONFIG_MODULE")
- else:
- celery.config_from_object("jass.celeryconfig")
- celery.conf.update(app.config)
- TaskBase = celery.Task
-
- class ContextTask(TaskBase):
- abstract = True
-
- def __call__(self, *args, **kwargs):
- with app.app_context():
- return TaskBase.__call__(self, *args, **kwargs)
-
- celery.Task = ContextTask
- return celery
-
-
-flask_app = Flask(__name__)
-celery = make_celery(flask_app)
-
-
-@celery.task
-def ensure_space_in_project_dir_task(project_id):
- ensure_space_in_project_dir(except_project_id=project_id)
-
-
-@celery.task
-def create_project_worktable(project_id):
- project = GlobalProject.load(project_id)
- return project.create_worktable_file()
-
-
-@celery.task
-def create_project_global_plot(project_id):
- project = GlobalProject.load(project_id)
- return project.create_global_manhattan_plot()
-
-
-@celery.task
-def create_project_quadrant_plot(project_id):
- project = GlobalProject.load(project_id)
- return project.create_quadrant_plot()
-
-
-@celery.task
-def create_project_local_plot(project_id):
- project = GlobalProject.load(project_id)
- return project.create_local_plot()
-
-
-@celery.task
-def create_project_qq_plot(project_id):
- project = GlobalProject.load(project_id)
- return project.create_qq_plot()
-
-
-@celery.task
-def create_project_csv_file(project_id):
- project = GlobalProject.load(project_id)
- return project.create_csv_file()
-
-
-@celery.task
-def create_project_metadata_file(project_id):
- project = GlobalProject.load(project_id)
- return project.create_project_metadata_file()
-
-
-@celery.task
-def dummy_task():
- print("This task to nothing, but help the chain to have a valid status")
-
-
-def get_queue_status():
- inspect = celery.control.inspect()
- workers = set()
- ret = {'active': 0, 'reserved': 0}
- for k in ['active', 'reserved']:
- try:
- for worker, queue in getattr(inspect, k)().items():
- ret[k] += len(queue)
- workers.add(worker)
- except (
- AttributeError, # when no worker
- ConnectionResetError, # when rabbitMQ went down
- TimeoutError, # when rabbitMQ is not reachable
- ):
- pass
- ret['worker'] = len(workers)
- return ret
-
-
-def run_project_analysis_if_needed(project):
- if project.has_computation_going_on():
- return
- tasks = []
- post_worktable_tasks = []
-
- if not os.path.exists(project.get_worktable_path()):
- tasks.append(create_project_worktable.si(project.id))
-
- if project.get_metadata_file_path() and not os.path.exists(project.get_metadata_file_path()):
- tasks.append(create_project_metadata_file.si(project.id))
-
- if project.get_global_manhattan_plot_path() and not os.path.exists(project.get_global_manhattan_plot_path()):
- post_worktable_tasks.append(create_project_global_plot.si(project.id))
-
- if project.get_quadrant_plot_path() and not os.path.exists(project.get_quadrant_plot_path()):
- post_worktable_tasks.append(create_project_quadrant_plot.si(project.id))
-
- if project.get_qq_plot_path() and not os.path.exists(project.get_qq_plot_path()):
- post_worktable_tasks.append(create_project_qq_plot.si(project.id))
-
- if project.get_csv_path() and not os.path.exists(project.get_csv_path()):
- post_worktable_tasks.append(create_project_csv_file.si(project.id))
-
- if len(tasks) + len(post_worktable_tasks) == 0:
- return
- main_wf = chain(
- # first we check again that there is enough disk space
- ensure_space_in_project_dir_task.si(project.id),
- # we run the main task(s)
- *tasks,
- # we then compute the missing charts
- group(post_worktable_tasks),
- # it is mandatory to add a task that do nothing if group is used in order to have a success/failure status
- dummy_task.si(),
- )
- task = main_wf.delay()
- project.celery_id = task.id
- # Artificially create a result for the chain/chord so its state will survive reboot of rabbitmq.
- # Otherwise, the status would be PENDING which we consider, even if no task are pending.
- task.backend.store_result(task.id, None, "SENT")
- project.save()
-
-
-def create_project(
- phenotype_ids: List[str],
- chromosome: str = None,
- start: str = None,
- end: str = None,
- init_table_name: str = None,
-):
- init_table_path = os.path.join(config["DATA_DIR"], init_table_name)
- available_phenotypes=get_available_phenotypes(init_table_path)
- unavailable_requested_ids = set(phenotype_ids).difference(
- set(phenotype.id for phenotype in available_phenotypes)
- )
- if len(unavailable_requested_ids) > 0:
- raise HTTPException(status_code=404, detail=f"Phenotype IDs not found: {','.join(unavailable_requested_ids)}")
- phenotypes = [
- phenotype for phenotype in available_phenotypes if phenotype.id in phenotype_ids
- ]
- project = GlobalProject(phenotypes=phenotypes, init_table_path=init_table_path)
-
- project.create(fail_if_exists=False)
- ensure_space_in_project_dir(except_project_id=project.id)
-
- # if project.get_type_of_analysis() == Project.LOCAL_ANALYSIS:
- # # Local Analysis
- # global_plot_path = None
- # quadrant_plot_path = None
- # zoom_plot_path = project.get_zoom_plot_path()
- # delayed_gen_csv_file = False
- # else:
- # # genome wide Analysis
- # global_plot_path = project.get_global_manhattan_plot_path()
- # quadrant_plot_path = project.get_quadrant_plot_path()
- # zoom_plot_path = None
- # delayed_gen_csv_file = True
-
- return project
diff --git a/jass/test/test_server.py.old b/jass/test/test_server.py.old
deleted file mode 100644
index 6234855e187645ceb519bf53df82f1f5b5dcbcc6..0000000000000000000000000000000000000000
--- a/jass/test/test_server.py.old
+++ /dev/null
@@ -1,91 +0,0 @@
-# coding: utf-8
-
-from __future__ import absolute_import
-import os, shutil, tempfile
-
-from six import BytesIO
-from flask import json, url_for
-
-from jass.config import config
-from . import JassWebClientTestCase
-
-
-class TestDefaultController(JassWebClientTestCase):
- """DefaultController integration test stubs"""
-
- test_folder = "data_real"
-
- def test_phenotypes_post(self):
- """
- Test case retrieving available phenotypes
- """
- response = self.testing_client.post("/api/phenotypes", json={})
- self.assert200(response, "Response body is : " + response.content.decode("utf-8"))
-
- response = self.testing_client.post(
- "/api/phenotypes",
- json={"initTableName": "initTable.hdf5"},
- )
- self.assert200(response, "Response body is : " + response.content.decode("utf-8"))
- json_response_main = json.loads(response.content.decode("utf-8"))
- phenotypes_main = set(p["id"] for p in json_response_main)
-
- response = self.testing_client.post(
- "/api/phenotypes",
- json={"initTableName": "initTableTest1.hdf5"},
- )
- self.assert200(response, "Response body is : " + response.content.decode("utf-8"))
- json_response_t1 = json.loads(response.content.decode("utf-8"))
- phenotypes_t1 = set(p["id"] for p in json_response_t1)
-
- self.assertNotEqual(json_response_t1, json_response_main)
- self.assertNotEqual(phenotypes_main, phenotypes_t1)
- self.assertEqual(phenotypes_main.intersection(phenotypes_t1), set())
-
- response = self.testing_client.post(
- "/api/phenotypes",
- json={"initTableName": "initTableMissing.hdf5"},
- )
- self.assertEqual(response.status_code, 404, response.content.decode("utf-8"))
-
- def test_create_project(self):
- """
- Test case for creating a project
- """
- response = self.testing_client.post(
- "/api/projects",
- json={"phenotypeID": ["z_MAGIC_FAST-GLUCOSE"]},
- )
- self.assert200(response, "Response body is : " + response.content.decode("utf-8"))
-
- def test_initmeta(self):
- response = self.testing_client.post("/api/initmeta", json={})
- self.assert200(response, "Response body is : " + response.content.decode("utf-8"))
- respMain = json.loads(response.content.decode("utf-8"))
-
- response = self.testing_client.post("/api/initmeta", json={"initTableName": "initTableTest1.hdf5"})
- self.assert200(response, "Response body is : " + response.content.decode("utf-8"))
- respT1 = json.loads(response.content.decode("utf-8"))
-
- self.assertNotEqual(respT1, respMain)
- for key in {
- 'nb_phenotypes',
- 'nb_snps',
- 'name',
- 'desc',
- 'ancestry',
- 'assembly',
- }:
- self.assertIn(key , respMain)
-
- def test_get_tables(self):
- response = self.testing_client.get("/api/tables")
- self.assert200(response, "Response body is : " + response.content.decode("utf-8"))
- resp = json.loads(response.content.decode("utf-8"))
- self.assertSetEqual({"initTable.hdf5", "initTableTest1.hdf5"}, set(resp))
-
-
-if __name__ == "__main__":
- import unittest
-
- unittest.main()