({
+ defaultValues: protocol,
+ });
+ useDirty(isDirty);
+ const [ updateProtocol ] = useProtocolUpdateMutation();
+
+ const { fields: doses, append: appendDose, remove: removeDose } = useFieldArray({
+ control,
+ name: "doses",
+ });
+
+ useEffect(() => {
+ reset(protocol);
+ }, [protocol, reset]);
+
+ const handleSave = handleSubmit((data: Protocol) => {
+ if (JSON.stringify(data) !== JSON.stringify(protocol)) {
+ updateProtocol({ id: protocol.id, protocol: data })
+ }
+ });
+
+ // save protocol every second if dirty
+ useEffect(() => {
+ const intervalId = setInterval(() => {
+ if (isDirty) {
+ console.log('saving protocol')
+ handleSave();
+ }
+ }, 1000);
+
+ return () => clearInterval(intervalId);
+ }, [handleSave, isDirty]);
+
+
+ useEffect(() => () => { handleSave(); }, []);
+
+ if (isVariableLoading) {
+ return Loading...
;
+ }
+
+ if (!variable) {
+ return Variable not found
;
+ }
+
+ const handleAddRow = () => {
+ appendDose({ amount: 0, repeats: 0, start_time: 0, repeat_interval: 1 });
+ }
+
+ const handleDeleteRow = (index: number) => {
+ removeDose(index);
+ }
+
+ const isPreclinical = project.species !== 'H';
+
+ return (
+ <>
+ {doses.map((dose, index) => (
+
+
+ {variable.name}
+
+
+
+
+ { protocol.amount_unit && index === 0 && (
+ u.id === protocol.amount_unit)} isPreclinicalPerKg={isPreclinical} />
+ )}
+
+
+
+
+
+
+
+
+
+
+ { protocol.time_unit && index === 0 && (
+ u.id === protocol.time_unit)}/>
+ )}
+
+
+ { index === 0 ? (
+
+
+ ) : (
+ handleDeleteRow(index)}>
+
+
+ )}
+
+
+ ))}
+
+ );
+};
+
+export default Doses;
diff --git a/frontend-v2/src/features/trial/Protocols.tsx b/frontend-v2/src/features/trial/Protocols.tsx
new file mode 100644
index 00000000..f5ff39b7
--- /dev/null
+++ b/frontend-v2/src/features/trial/Protocols.tsx
@@ -0,0 +1,69 @@
+// src/components/ProjectTable.tsx
+import React from "react";
+import { useSelector } from "react-redux";
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableContainer,
+ TableHead,
+ TableRow,
+} from "@mui/material";
+import { useUnitListQuery, useProjectRetrieveQuery, useProtocolListQuery } from "../../app/backendApi";
+import { RootState } from "../../app/store";
+import Doses from "./Doses";
+import HelpButton from "../../components/HelpButton";
+
+
+const Protocols: React.FC = () => {
+ const selectedProject = useSelector((state: RootState) => state.main.selectedProject);
+ const { data: project, error: projectError, isLoading: isProjectLoading } = useProjectRetrieveQuery({id: selectedProject || 0}, { skip: !selectedProject })
+ const { data: protocols, error: protocolsError, isLoading: isProtocolsLoading } = useProtocolListQuery({projectId: selectedProject || 0}, { skip: !selectedProject })
+ const { data: units, isLoading: unitsLoading } = useUnitListQuery({ compoundId: project?.compound || 0}, { skip: !project?.compound})
+
+ if (isProjectLoading || isProtocolsLoading || unitsLoading) {
+ return Loading...
;
+ }
+
+ if (!project || !protocols || !units) {
+ return Project not found
;
+ }
+
+ const filteredProtocols = protocols?.filter((protocol) => protocol.variables.length > 0);
+
+
+ return (
+
+
+
+
+ Site of AdminDefined in Model/Map Variables
+ Dose
+ Dose UnitDefault selection: mg/kg for preclinical, mg for clinical
+ Number of Doses
+ Start TimeStart time of the first dose
+ Dose DurationDuration of dosing. For IV bolus PO/SC dosing use the default value 0.0833 h
+ Dosing Interval
+ Time Unit
+
+ Add Dose Line Adding an additional dosing line allows defining complex dosing regimens (e.g. changing dosing frequency and/or dosing levels)
+
+
+
+
+ {protocols?.length === 0 && (
+
+ No protocols found
+
+ )}
+ {filteredProtocols?.map((protocol) => (
+
+
+
+
+ );
+};
+
+export default Protocols;
diff --git a/frontend-v2/src/hooks/useDirty.ts b/frontend-v2/src/hooks/useDirty.ts
new file mode 100644
index 00000000..2a504137
--- /dev/null
+++ b/frontend-v2/src/hooks/useDirty.ts
@@ -0,0 +1,18 @@
+import { useDispatch } from "react-redux";
+import { decrementDirtyCount, incrementDirtyCount } from "../features/main/mainSlice";
+import { useEffect, useState } from "react";
+
+function useDirty(isDirty: boolean) {
+ const dispatch = useDispatch();
+ useEffect(() => {
+ if (isDirty) {
+ dispatch(incrementDirtyCount())
+ return () => {
+ dispatch(decrementDirtyCount())
+ };
+ }
+
+ }, [isDirty]);
+}
+
+export default useDirty;
\ No newline at end of file
diff --git a/frontend-v2/src/hooks/usePrevious.ts b/frontend-v2/src/hooks/usePrevious.ts
new file mode 100644
index 00000000..638b9d3f
--- /dev/null
+++ b/frontend-v2/src/hooks/usePrevious.ts
@@ -0,0 +1,11 @@
+import { useEffect, useRef } from "react";
+
+function usePrevious(value: any) {
+ const ref = useRef();
+ useEffect(() => {
+ ref.current = value; //assign the value of ref to the argument
+ },[value]); //this code will run when the value of 'value' changes
+
+ return ref.current; //in the end, return the current ref value.
+}
+export default usePrevious;
\ No newline at end of file
diff --git a/frontend-v2/src/index.css b/frontend-v2/src/index.css
new file mode 100644
index 00000000..ec2585e8
--- /dev/null
+++ b/frontend-v2/src/index.css
@@ -0,0 +1,13 @@
+body {
+ margin: 0;
+ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+ 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+ sans-serif;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+}
+
+code {
+ font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
+ monospace;
+}
diff --git a/frontend-v2/src/index.tsx b/frontend-v2/src/index.tsx
new file mode 100644
index 00000000..0e6466fa
--- /dev/null
+++ b/frontend-v2/src/index.tsx
@@ -0,0 +1,23 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { Provider } from 'react-redux';
+import { store } from './app/store';
+import App from './App';
+import reportWebVitals from './reportWebVitals';
+import './index.css';
+
+const container = document.getElementById('root')!;
+const root = createRoot(container);
+
+root.render(
+
+
+
+
+);
+
+// If you want to start measuring performance in your app, pass a function
+// to log results (for example: reportWebVitals(console.log))
+// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
+reportWebVitals();
diff --git a/frontend-v2/src/logo.svg b/frontend-v2/src/logo.svg
new file mode 100644
index 00000000..84667388
--- /dev/null
+++ b/frontend-v2/src/logo.svg
@@ -0,0 +1 @@
+PKPD APP PKPDApp
+
+
+ You need to enable JavaScript to run this app.
+
+
+
+
diff --git a/frontend/public/logo.svg b/frontend/public/logo.svg
new file mode 100644
index 00000000..465cf440
--- /dev/null
+++ b/frontend/public/logo.svg
@@ -0,0 +1,79 @@
+
+
+
diff --git a/frontend/public/logo192.png b/frontend/public/logo192.png
new file mode 100644
index 00000000..fc44b0a3
Binary files /dev/null and b/frontend/public/logo192.png differ
diff --git a/frontend/public/logo512.png b/frontend/public/logo512.png
new file mode 100644
index 00000000..a4e47a65
Binary files /dev/null and b/frontend/public/logo512.png differ
diff --git a/frontend/public/manifest.json b/frontend/public/manifest.json
new file mode 100644
index 00000000..080d6c77
--- /dev/null
+++ b/frontend/public/manifest.json
@@ -0,0 +1,25 @@
+{
+ "short_name": "React App",
+ "name": "Create React App Sample",
+ "icons": [
+ {
+ "src": "favicon.ico",
+ "sizes": "64x64 32x32 24x24 16x16",
+ "type": "image/x-icon"
+ },
+ {
+ "src": "logo192.png",
+ "type": "image/png",
+ "sizes": "192x192"
+ },
+ {
+ "src": "logo512.png",
+ "type": "image/png",
+ "sizes": "512x512"
+ }
+ ],
+ "start_url": ".",
+ "display": "standalone",
+ "theme_color": "#000000",
+ "background_color": "#ffffff"
+}
diff --git a/frontend/public/robots.txt b/frontend/public/robots.txt
new file mode 100644
index 00000000..e9e57dc4
--- /dev/null
+++ b/frontend/public/robots.txt
@@ -0,0 +1,3 @@
+# https://www.robotstxt.org/robotstxt.html
+User-agent: *
+Disallow:
diff --git a/frontend/src/Api.js b/frontend/src/Api.js
new file mode 100644
index 00000000..0ae69561
--- /dev/null
+++ b/frontend/src/Api.js
@@ -0,0 +1,102 @@
+// derived from https://jasonwatmore.com/post/2020/04/18/fetch-a-lightweight-fetch-wrapper-to-simplify-http-requests
+export const api = {
+ get,
+ post,
+ patch,
+ put,
+ putMultiPart,
+ delete: _delete,
+};
+
+function get(url, csrf) {
+ const requestOptions = {
+ method: "GET",
+ headers: {
+ "X-CSRFToken": csrf,
+ },
+ };
+ return fetch(url, requestOptions).then(handleResponse);
+}
+
+function post(url, csrf, body) {
+ let requestOptions = {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(body),
+ };
+ if (csrf) {
+ requestOptions.headers["X-CSRFToken"] = csrf;
+ }
+ return fetch(url, requestOptions).then(handleResponse);
+}
+
+function put(url, csrf, body) {
+ const requestOptions = {
+ method: "PUT",
+ headers: {
+ "Content-Type": "application/json",
+ "X-CSRFToken": csrf,
+ },
+ body: JSON.stringify(body),
+ };
+ return fetch(url, requestOptions).then(handleResponse);
+}
+
+function putMultiPart(url, csrf, data) {
+ const formData = new FormData();
+
+ for (const name in data) {
+ formData.append(name, data[name]);
+ }
+ const requestOptions = {
+ method: "PUT",
+ headers: {
+ "X-CSRFToken": csrf,
+ },
+ body: formData,
+ };
+ return fetch(url, requestOptions).then(handleResponse);
+}
+
+function patch(url, csrf, body) {
+ const requestOptions = {
+ method: "PATCH",
+ headers: {
+ "Content-Type": "application/json",
+ "X-CSRFToken": csrf,
+ },
+ body: JSON.stringify(body),
+ };
+ return fetch(url, requestOptions).then(handleResponse);
+}
+
+// prefixed with underscored because delete is a reserved word in javascript
+function _delete(url, csrf) {
+ const requestOptions = {
+ method: "DELETE",
+ headers: {
+ "X-CSRFToken": csrf,
+ },
+ };
+ return fetch(url, requestOptions).then(handleResponse);
+}
+
+// helper functions
+
+function handleResponse(response) {
+ return response.text().then((text) => {
+ let data = {};
+ try {
+ data = text && JSON.parse(text);
+ } catch (e) {
+ alert(text);
+ }
+ if (!response.ok) {
+ console.log("API error:", response, response.statusText, data);
+ return Promise.reject(data);
+ }
+ return data;
+ });
+}
diff --git a/frontend/src/App.css b/frontend/src/App.css
new file mode 100644
index 00000000..74b5e053
--- /dev/null
+++ b/frontend/src/App.css
@@ -0,0 +1,38 @@
+.App {
+ text-align: center;
+}
+
+.App-logo {
+ height: 40vmin;
+ pointer-events: none;
+}
+
+@media (prefers-reduced-motion: no-preference) {
+ .App-logo {
+ animation: App-logo-spin infinite 20s linear;
+ }
+}
+
+.App-header {
+ background-color: #282c34;
+ min-height: 100vh;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ justify-content: center;
+ font-size: calc(10px + 2vmin);
+ color: white;
+}
+
+.App-link {
+ color: #61dafb;
+}
+
+@keyframes App-logo-spin {
+ from {
+ transform: rotate(0deg);
+ }
+ to {
+ transform: rotate(360deg);
+ }
+}
diff --git a/frontend/src/App.js b/frontend/src/App.js
new file mode 100644
index 00000000..2155d3ee
--- /dev/null
+++ b/frontend/src/App.js
@@ -0,0 +1,402 @@
+import React, { useEffect } from "react";
+import {
+ Switch,
+ Route,
+ Link,
+ matchPath,
+ Redirect,
+ useParams,
+ useLocation,
+ useHistory,
+} from "react-router-dom";
+import { useDispatch } from "react-redux";
+import { ThemeProvider, StyledEngineProvider, createTheme } from '@mui/material/styles';
+import { AdapterDayjs } from '@mui/x-date-pickers/AdapterDayjs';
+import { LocalizationProvider, DatePicker } from '@mui/x-date-pickers';
+//import { AdapterDateFns } from '@mui/x-date-pickers/AdapterDateFns';
+//import enUS from 'date-fns/locale/en-US';
+import 'dayjs/locale/en-gb';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+
+
+import DateFnsUtils from "@date-io/date-fns";
+import Container from "@mui/material/Container";
+import Login from "./features/login/Login";
+import Register from "./features/login/Register";
+import RegisterSuccess from "./features/login/RegisterSuccess";
+import ActivateUser from "./features/login/ActivateUser";
+import ActivateUserSuccess from "./features/login/ActivateUserSuccess";
+import ResetPasswordRequest from "./features/login/ResetPasswordRequest";
+import ResetPasswordRequestSuccess from "./features/login/ResetPasswordRequestSuccess";
+import ResetPassword from "./features/login/ResetPassword";
+import ResetPasswordSuccess from "./features/login/ResetPasswordSuccess";
+
+import { alpha } from "@mui/material/styles";
+import makeStyles from '@mui/styles/makeStyles';
+import CssBaseline from "@mui/material/CssBaseline";
+
+import SearchIcon from "@mui/icons-material/Search";
+
+import InputBase from "@mui/material/InputBase";
+
+import clsx from "clsx";
+import Drawer from "@mui/material/Drawer";
+import AppBar from "@mui/material/AppBar";
+import Toolbar from "@mui/material/Toolbar";
+import Typography from "@mui/material/Typography";
+import Divider from "@mui/material/Divider";
+import IconButton from "@mui/material/IconButton";
+import Button from "@mui/material/Button";
+import ButtonGroup from "@mui/material/ButtonGroup";
+import MenuIcon from "@mui/icons-material/Menu";
+import ChevronLeftIcon from "@mui/icons-material/ChevronLeft";
+
+import { api } from "./Api";
+import InferenceMenu from "./features/menu/InferenceMenu";
+import Projects from "./features/projects/Projects";
+import Project from "./features/projects/Project";
+import RequireLogin from "./features/login/RequireLogin";
+
+
+import { logout, fetchSession } from "./features/login/loginSlice";
+import { fetchAlgorithms } from "./features/inference/algorithmsSlice.js";
+import { fetchUnits } from "./features/projects/unitsSlice.js";
+import { fetchUsers } from "./features/projects/usersSlice.js";
+import { fetchProjects } from "./features/projects/projectsSlice.js";
+
+dayjs.extend(utc);
+
+const drawerWidth = 240;
+
+const useStyles = makeStyles((theme) => ({
+ grow: {
+ flexGrow: 1,
+ },
+ root: {
+ display: "flex",
+ },
+ title: {
+ display: "none",
+ [theme.breakpoints.up("sm")]: {
+ display: "block",
+ },
+ },
+ search: {
+ position: "relative",
+ borderRadius: theme.shape.borderRadius,
+ backgroundColor: alpha(theme.palette.common.white, 0.15),
+ "&:hover": {
+ backgroundColor: alpha(theme.palette.common.white, 0.25),
+ },
+ marginRight: theme.spacing(2),
+ marginLeft: 0,
+ width: "100%",
+ [theme.breakpoints.up("sm")]: {
+ marginLeft: theme.spacing(3),
+ width: "auto",
+ },
+ },
+ searchIcon: {
+ padding: theme.spacing(0, 2),
+ height: "100%",
+ position: "absolute",
+ pointerEvents: "none",
+ display: "flex",
+ alignItems: "center",
+ justifyContent: "center",
+ },
+ inputRoot: {
+ color: "inherit",
+ },
+ inputInput: {
+ padding: theme.spacing(1, 1, 1, 0),
+ // vertical padding + font size from searchIcon
+ paddingLeft: `calc(1em + ${theme.spacing(4)})`,
+ transition: theme.transitions.create("width"),
+ width: "100%",
+ [theme.breakpoints.up("md")]: {
+ width: "20ch",
+ },
+ },
+ toolbar: {
+ paddingRight: 24, // keep right padding when drawer closed
+ },
+ toolbarIcon: {
+ display: "flex",
+ alignItems: "center",
+ justifyContent: "flex-end",
+ padding: "0 8px",
+ ...theme.mixins.toolbar,
+ },
+ appBar: {
+ zIndex: theme.zIndex.drawer + 1,
+ transition: theme.transitions.create(["width", "margin"], {
+ easing: theme.transitions.easing.sharp,
+ duration: theme.transitions.duration.leavingScreen,
+ }),
+ },
+ appBarShift: {
+ marginLeft: drawerWidth,
+ width: `calc(100% - ${drawerWidth}px)`,
+ transition: theme.transitions.create(["width", "margin"], {
+ easing: theme.transitions.easing.sharp,
+ duration: theme.transitions.duration.enteringScreen,
+ }),
+ },
+ galvanalyserLogo: {
+ height: "40px",
+ },
+ menuButton: {
+ marginRight: 36,
+ },
+ menuButtonHidden: {
+ display: "none",
+ },
+
+ drawerPaper: {
+ position: "relative",
+ overflowX: "hidden",
+ whiteSpace: "nowrap",
+ width: drawerWidth,
+ height: "100%",
+ transition: theme.transitions.create("width", {
+ easing: theme.transitions.easing.sharp,
+ duration: theme.transitions.duration.enteringScreen,
+ }),
+ },
+
+ drawerPaperClose: {
+ overflowX: "hidden",
+ transition: theme.transitions.create("width", {
+ easing: theme.transitions.easing.sharp,
+ duration: theme.transitions.duration.leavingScreen,
+ }),
+ width: theme.spacing(7),
+ height: "100%",
+ [theme.breakpoints.up("sm")]: {
+ width: theme.spacing(9),
+ },
+ },
+ appBarSpacer: theme.mixins.toolbar,
+ content: {
+ flexGrow: 1,
+ overflow: "auto",
+ },
+ container: {
+ paddingTop: theme.spacing(10),
+ paddingBottom: theme.spacing(4),
+ },
+ paper: {
+ padding: theme.spacing(2),
+ display: "flex",
+ overflow: "auto",
+ flexDirection: "column",
+ },
+ fixedHeight: {
+ height: 240,
+ },
+ nested: {
+ paddingLeft: theme.spacing(4),
+ },
+ avatarPlusSmall: {
+ width: theme.spacing(3),
+ height: theme.spacing(3),
+ backgroundColor: theme.palette.primary.main,
+ },
+ avatarPlus: {
+ width: theme.spacing(5),
+ height: theme.spacing(5),
+ backgroundColor: theme.palette.primary.main,
+ },
+ colorSelected: {
+ backgroundColor: theme.palette.secondary.main,
+ },
+ avatarSmall: {
+ width: theme.spacing(3),
+ height: theme.spacing(3),
+ },
+ avatar: {
+ width: theme.spacing(5),
+ height: theme.spacing(5),
+ backgroundColor: theme.palette.secondary.main,
+ },
+ large: {
+ width: theme.spacing(7),
+ height: theme.spacing(7),
+ },
+ noPadding: {
+ margin: 0,
+ marginRight: 0,
+ marginLeft: 0,
+ padding: 0,
+ },
+}));
+
+function LoggedInApp() {
+ const classes = useStyles();
+ const [open, setOpen] = React.useState(true);
+
+ const handleDrawerOpenClose = () => {
+ setOpen((prevOpen) => !prevOpen);
+ };
+
+ const handleLogout = () => {
+ dispatch(logout());
+ }
+
+ let history = useHistory();
+ const dispatch = useDispatch();
+
+ useEffect(() => {
+ dispatch(fetchProjects());
+ dispatch(fetchUsers());
+ dispatch(fetchUnits());
+ dispatch(fetchAlgorithms());
+ //const interval = setInterval(() => {
+ // refreshHarvesters();
+ //}, 5000);
+ //return () => clearInterval(interval);
+ }, [dispatch]);
+
+ const { pathname } = useLocation();
+ const matchProject = matchPath(pathname, { path: '/:id'})
+
+ const rootPath = "/";
+ const isRootPath = !!matchPath(pathname, { path: rootPath, exact: true });
+ console.log('pathname', pathname)
+ let modellingPath = ''
+ let isModellingPath = false
+ let inferencePath = ''
+ let isInferencePath = false
+ if (matchProject) {
+ modellingPath = `/${matchProject.params.id}`;
+ isModellingPath = !!matchPath(pathname, {
+ path: modellingPath,
+ exact: true,
+ });
+ inferencePath = `/${matchProject.params.id}/inference`;
+ isInferencePath = !!matchPath(pathname, {
+ path: inferencePath,
+ });
+ }
+ return (
+
+
+
+
+
+
+ PKPDapp
+
+ { !isRootPath &&
+
+
+
+
+
+ Home
+
+
+ Workbench
+
+
+
+ Inferences
+
+
+
+ }
+
+
+
+ Logout
+
+
+
+ {/* A
looks through its children s and
+ renders the first one that matches the current URL. */}
+
+
+
+
+
+
+
+
+ ;
+
+
+
+
+
+
+
+
+
+
+ );
+}
diff --git a/frontend/src/App.test.js b/frontend/src/App.test.js
new file mode 100644
index 00000000..9382b9ad
--- /dev/null
+++ b/frontend/src/App.test.js
@@ -0,0 +1,8 @@
+import { render, screen } from "@testing-library/react";
+import App from "./App";
+
+test("renders learn react link", () => {
+ render(
+ {renderChart &&
+ );
+}
+
+export function AuceChartFitsVsConcentration({ auces, biomarker_type }) {
+ const classes = useStyles();
+ const renderChart = true;
+
+ let datasets = [];
+ var i = 0;
+ for (const auce of auces) {
+ const data = auce.x ? auce.x.map((x, i) => ({ x: x, y: auce.y[i] })) : null;
+ const dataLower = auce.x
+ ? auce.x.map((x, i) => ({ x: x, y: auce.y_lower[i] }))
+ : null;
+ const dataUpper = auce.x
+ ? auce.x.map((x, i) => ({ x: x, y: auce.y_upper[i] }))
+ : null;
+ const dataPoints = auce.auce
+ ? auce.concentrations.map((x, i) => ({ x: x, y: auce.auce[i] }))
+ : null;
+ if (data) {
+ datasets.push({
+ borderColor: getColor(i),
+ backgroundColor: getColorBackground(i),
+ label: "noLabel" + auce.name + "Fit",
+ pointRadius: 0,
+ fill: false,
+ type: "line",
+ data: data,
+ });
+ }
+ if (dataLower) {
+ datasets.push({
+ borderColor: getColorBackground(i),
+ backgroundColor: getColorBackground(i),
+ type: "line",
+ pointRadius: 0,
+ fill: false,
+ label: "noLabel" + auce.name + "Lower",
+ data: dataLower,
+ });
+ }
+ if (dataUpper) {
+ datasets.push({
+ borderColor: getColorBackground(i),
+ backgroundColor: getColorBackground(i),
+ type: "line",
+ pointRadius: 0,
+ fill: "-1", // fill to previous dataset
+ //fill: false,
+ label: "noLabel" + auce.name + "Upper",
+ data: dataUpper,
+ });
+ }
+ if (dataPoints) {
+ datasets.push({
+ borderColor: getColor(i),
+ backgroundColor: getColor(i),
+ label: auce.name,
+ data: dataPoints,
+ });
+ }
+ i += 1;
+ }
+
+ const data = { datasets };
+
+ const optionsVsConcentration = {
+ ...options,
+ scales: {
+ x: {
+ type: "logarithmic",
+ title: {
+ text: "Concentration",
+ display: true,
+ },
+ },
+ y: {
+ type: "logarithmic",
+ position: "left",
+ title: {
+ text: "AUCE",
+ display: true,
+ },
+ },
+ },
+ plugins: {
+ ...options.plugins,
+ crosshair: false,
+ }
+ };
+
+ return (
+
+ {renderChart &&
+ );
+}
diff --git a/frontend/src/features/dataAnalysis/AuceDetail.js b/frontend/src/features/dataAnalysis/AuceDetail.js
new file mode 100644
index 00000000..7a962ea2
--- /dev/null
+++ b/frontend/src/features/dataAnalysis/AuceDetail.js
@@ -0,0 +1,101 @@
+import React, { useEffect, useState } from "react";
+import { useSelector } from "react-redux";
+import Alert from '@mui/material/Alert';
+import makeStyles from '@mui/styles/makeStyles';
+
+import Select from "@mui/material/Select";
+import InputLabel from "@mui/material/InputLabel";
+import MenuItem from "@mui/material/MenuItem";
+import FormControl from "@mui/material/FormControl";
+
+import { AuceChartDataVsTime, AuceChartFitsVsConcentration } from "./AuceChart";
+import {
+ selectBiomarkerTypesByDatasetId,
+ selectBiomarkerTypeById,
+} from "../datasets/biomarkerTypesSlice";
+
+import { api } from "../../Api";
+
+const useStyles = makeStyles((theme) => ({
+ root: {
+ marginTop: theme.spacing(2),
+ flexGrow: 1,
+ },
+ formControl: {
+ margin: theme.spacing(1),
+ minWidth: 120,
+ },
+}));
+
+export default function AuceDetail({ project, dataset }) {
+ const classes = useStyles();
+ const [auce, setAuce] = useState([]);
+ const [apiError, setApiError] = useState(null);
+ const [biomarkerTypeId, setBiomarkerTypeId] = useState(null);
+ const biomarker_type = useSelector((state) =>
+ biomarkerTypeId ? selectBiomarkerTypeById(state, biomarkerTypeId) : null
+ );
+
+ const biomarkerTypes = useSelector((state) =>
+ selectBiomarkerTypesByDatasetId(state, dataset.id)
+ );
+
+ useEffect(() => {
+ if (biomarkerTypeId != null) {
+ api
+ .post(`/api/auce/`, {
+ biomarker_type_id: biomarkerTypeId,
+ })
+ .then(setAuce)
+ .catch((data) => setApiError(data["biomarker_type_id"]));
+ }
+ }, [biomarkerTypeId]);
+
+ const handleBiomarkerTypeChange = (event) => {
+ setBiomarkerTypeId(event.target.value);
+ };
+
+ const fitErrors = auce
+ .map((x) => (x.x ? null : `Sigmoid fit failed for ${x.name}`))
+ .filter((x) => x);
+
+ return (
+
+
+ Variable
+
+ {biomarkerTypes.map((bt, i) => {
+ return (
+
+ {bt.name}
+
+ );
+ })}
+
+
+
+ {apiError &&
{apiError} }
+ {fitErrors &&
+ fitErrors.map((fitError, i) => (
+
+ {fitError}
+
+ ))}
+
+ {auce && (
+
+ )}
+
+ {auce && (
+
+ )}
+
+ {renderChart &&
+ );
+}
diff --git a/frontend/src/features/dataAnalysis/NcaDetail.js b/frontend/src/features/dataAnalysis/NcaDetail.js
new file mode 100644
index 00000000..48720351
--- /dev/null
+++ b/frontend/src/features/dataAnalysis/NcaDetail.js
@@ -0,0 +1,167 @@
+import React, { useEffect, useState } from "react";
+import { useSelector } from "react-redux";
+import makeStyles from '@mui/styles/makeStyles';
+
+import Select from "@mui/material/Select";
+import InputLabel from "@mui/material/InputLabel";
+import MenuItem from "@mui/material/MenuItem";
+import FormControl from "@mui/material/FormControl";
+
+import { NcaChart } from "./NcaChart";
+import {
+ selectProtocolById,
+} from "../protocols/protocolsSlice";
+import {
+ selectDatasetById,
+} from "../datasets/datasetsSlice";
+import {
+ selectBiomarkerTypesByDatasetId,
+ selectBiomarkerTypeById,
+} from "../datasets/biomarkerTypesSlice";
+
+import { selectSubjectById } from "../datasets/subjectsSlice";
+
+import { api } from "../../Api";
+
+const useStyles = makeStyles((theme) => ({
+ root: {
+ marginTop: theme.spacing(2),
+ flexGrow: 1,
+ },
+ formControl: {
+ margin: theme.spacing(1),
+ minWidth: 120,
+ },
+}));
+
+export default function NcaDetail({ project, dataset }) {
+ const classes = useStyles();
+ const [nca, setNca] = useState(null);
+ const [subjectId, setSubjectId] = useState(null);
+ const [mode, setMode] = useState("data");
+ const modeOptions = [
+ { key: "Data", value: "data" },
+ { key: "Maximum and Extrapolation", value: "extrapolation" },
+ { key: "Area Under the Curve", value: "auc" },
+ { key: "Area Under the First Moment", value: "aucm" },
+ ];
+
+ const [biomarkerTypeId, setBiomarkerTypeId] = useState(null);
+ const biomarker_type = useSelector((state) =>
+ biomarkerTypeId ? selectBiomarkerTypeById(state, biomarkerTypeId) : null
+ );
+
+
+ const subject = useSelector((state) =>
+ subjectId ? selectSubjectById(state, subjectId) : null
+ );
+
+ const biomarkerTypes = useSelector((state) =>
+ selectBiomarkerTypesByDatasetId(state, dataset.id)
+ );
+
+ const subjectsEntities = useSelector((state) => state.subjects.entities);
+
+ const subjectsInBiomarkerType = biomarkerTypeId
+ ? [... new Set(biomarker_type.data.subjects)]
+ : [];
+
+ const subjectOptions = subjectsInBiomarkerType.filter(s_id =>
+ (subjectsEntities[s_id].protocol)
+ ).map(s_id => ({
+ key: subjectsEntities[s_id].id_in_dataset, value: s_id
+ }))
+
+ useEffect(() => {
+ if (biomarkerTypeId != null && subjectId != null) {
+ api
+ .post(`/api/nca/`, {
+ biomarker_type_id: biomarkerTypeId,
+ subject_id: subjectId,
+ })
+ .then(setNca);
+ } else {
+ setNca(null)
+ }
+ }, [biomarkerTypeId, subjectId]);
+
+ const handleSubjectChange = (event) => {
+ setSubjectId(event.target.value);
+ };
+ const handleBiomarkerTypeChange = (event) => {
+ setBiomarkerTypeId(event.target.value);
+ setSubjectId(null);
+ };
+ const handleModeChange = (event) => {
+ setMode(event.target.value);
+ };
+
+ console.log("nca", nca);
+
+ return (
+
+
+ Variable
+
+ {biomarkerTypes.map((bt, i) => {
+ return (
+
+ {bt.name}
+
+ );
+ })}
+
+
+
+
+ Subject
+
+ {subjectOptions.map((s, i) => {
+ return (
+
+ {s.key}
+
+ );
+ })}
+
+
+
+
+ {nca && subject && (
+
+ Show
+
+ {modeOptions.map((mode, i) => {
+ return (
+
+ {mode.key}
+
+ );
+ })}
+
+
+ )}
+
+ {nca && subject && (
+
+ );
+}
diff --git a/frontend/src/features/datasets/BiomarkerTypeSubform.js b/frontend/src/features/datasets/BiomarkerTypeSubform.js
new file mode 100644
index 00000000..01b08e4e
--- /dev/null
+++ b/frontend/src/features/datasets/BiomarkerTypeSubform.js
@@ -0,0 +1,136 @@
+import React, { useEffect } from "react";
+import { useSelector, useDispatch } from "react-redux";
+import IconButton from "@mui/material/IconButton";
+import { useForm, useFormState } from "react-hook-form";
+import SaveIcon from "@mui/icons-material/Save";
+import Stack from "@mui/material/Stack";
+import Grid from "@mui/material/Grid";
+
+import {
+ FormCheckboxField,
+ FormTextField,
+ FormSelectField,
+} from "../forms/FormComponents";
+import { selectUnitById } from "../projects/unitsSlice";
+import {
+ selectBiomarkerTypeById,
+ updateBiomarkerType,
+} from "./biomarkerTypesSlice";
+
+export default function BiomarkerTypeSubform({ biomarker_id, disableSave }) {
+ const dispatch = useDispatch();
+ let biomarker_type = useSelector((state) =>
+ selectBiomarkerTypeById(state, biomarker_id)
+ );
+ if (!biomarker_type) {
+ biomarker_type = {
+ default_value: false,
+ axis: false,
+ };
+ }
+ const unit_id = biomarker_type ? biomarker_type.display_unit : 1;
+ let unit = useSelector((state) => selectUnitById(state, unit_id));
+ if (!unit) {
+ unit = {
+ symbol: "X",
+ compatible_units: [],
+ };
+ }
+ const unitOptions = unit.compatible_units.map((u) => {
+ return { key: u.symbol, value: u.id };
+ });
+
+ const time_unit_id = biomarker_type ? biomarker_type.display_time_unit : 1;
+ let time_unit = useSelector((state) => selectUnitById(state, time_unit_id));
+ if (!time_unit) {
+ time_unit = {
+ symbol: "X",
+ compatible_units: [],
+ };
+ }
+ const timeUnitOptions = time_unit.compatible_units.map((u) => {
+ return { key: u.symbol, value: u.id };
+ });
+
+ const { control, handleSubmit, reset } = useForm({
+ defaultValues: {
+ id: biomarker_type.id,
+ display: biomarker_type.display,
+ name: biomarker_type.name,
+ color: biomarker_type.color,
+ display_unit: biomarker_type.display_unit,
+ display_time_unit: biomarker_type.display_time_unit,
+ axis: biomarker_type.axis,
+ },
+ });
+
+ const { isDirty } = useFormState({ control });
+
+ useEffect(() => {
+ reset(biomarker_type);
+ }, [reset, biomarker_type]);
+
+ const onSubmit = (values) => {
+ console.log("submit biomarker_type", values);
+ dispatch(updateBiomarkerType(values));
+ };
+
+ const axisOptions = [
+ { value: false, key: "LHS" },
+ { value: true, key: "RHS" },
+ ];
+
+ return (
+
+
+
+
+
+
+
+
+ {isDirty && (
+
+
+ )}
+
+
+ );
+}
diff --git a/frontend/src/features/datasets/DatasetDetail.js b/frontend/src/features/datasets/DatasetDetail.js
new file mode 100644
index 00000000..8ecc46b4
--- /dev/null
+++ b/frontend/src/features/datasets/DatasetDetail.js
@@ -0,0 +1,221 @@
+import React, { useEffect } from "react";
+import { useDispatch, useSelector } from "react-redux";
+import Button from "@mui/material/Button";
+import Grid from "@mui/material/Grid";
+import Box from "@mui/material/Box";
+import Alert from '@mui/material/Alert';
+import { useForm } from "react-hook-form";
+import makeStyles from '@mui/styles/makeStyles';
+import Typography from "@mui/material/Typography";
+import List from "@mui/material/List";
+import ListItem from "@mui/material/ListItem";
+import Dialog from "@mui/material/Dialog";
+import DialogTitle from "@mui/material/DialogTitle";
+import DialogActions from "@mui/material/DialogActions";
+import Tab from "@mui/material/Tab";
+import Tabs from "@mui/material/Tabs";
+import Stack from "@mui/material/Stack";
+
+import Accordion from "@mui/material/Accordion";
+import AccordionSummary from "@mui/material/AccordionSummary";
+import Paper from "@mui/material/Paper";
+import AccordionDetails from "@mui/material/AccordionDetails";
+import ExpandMoreIcon from "@mui/icons-material/ExpandMore";
+
+import Header from "../modelling/Header";
+import Footer from "../modelling/Footer";
+import SubjectsTable from "./SubjectsTable";
+import BiomarkerTypeSubform from "./BiomarkerTypeSubform";
+
+import AuceDetail from "../dataAnalysis/AuceDetail"
+import NcaDetail from "../dataAnalysis/NcaDetail"
+
+import { userHasReadOnlyAccess } from "../projects/projectsSlice";
+
+import {
+ updateDataset,
+ uploadDatasetCsv,
+ deleteDataset,
+} from "../datasets/datasetsSlice";
+import { FormTextField, FormDateTimeField } from "../forms/FormComponents";
+
+const useStyles = makeStyles((theme) => ({
+ root: {
+ width: "100%",
+ padding: theme.spacing(2),
+ maxHeight: '75vh', overflow: 'auto'
+ },
+ rootTab: {
+ width: "100%",
+ padding: theme.spacing(2),
+ height: '75vh', overflow: 'auto'
+ },
+ paper: {
+ padding: theme.spacing(2)
+ },
+ tabs: {
+ backgroundColor: theme.palette.primary.main,
+ color: theme.palette.primary.contrastText,
+ borderBottom: 1,
+ borderColor: 'divider',
+ },
+ dialogFooter: {
+ }
+}));
+
+function TabPanel(props) {
+ const { children, value, index, ...other } = props;
+
+ return (
+
+ {value === index && (
+
+ {children}
+
+ )}
+
+ );
+}
+
+function a11yProps(index: number) {
+ return {
+ id: `simple-tab-${index}`,
+ 'aria-controls': `simple-tabpanel-${index}`,
+ };
+}
+
+function DataAnalysisDialog({ project, onClose, dataset, open }) {
+ const classes = useStyles();
+ const [value, setValue] = React.useState(0);
+ const handleClose = () => {
+ onClose();
+ };
+
+ const handleChange = (event, newValue) => {
+ setValue(newValue);
+ };
+
+ return (
+
+
+
+
+
+
+
+
+
+
+
+ Close
+
+
+
+ );
+}
+
+
+export default function DatasetDetail({ project, dataset }) {
+ const { control, handleSubmit, reset } = useForm();
+ const dispatch = useDispatch();
+
+ const [openDataAnalysis, setOpenDataAnalysis] = React.useState(false);
+ const handleDataAnalysis = () => {
+ setOpenDataAnalysis(true);
+ };
+ const handleCloseDataAnalysis = () => {
+ setOpenDataAnalysis(false);
+ };
+
+ useEffect(() => {
+ reset(dataset);
+ }, [reset, dataset]);
+
+
+ const handleDatasetDelete = () => {
+ dispatch(deleteDataset(dataset.id));
+ };
+
+ const handleFileUpload = (event) => {
+ console.log(event)
+ const files = Array.from(event.target.files);
+ const [file] = files;
+ dispatch(uploadDatasetCsv({ id: dataset.id, csv: file }));
+ };
+
+ const onSubmit = (values) => {
+ dispatch(updateDataset(values));
+ };
+
+ const disableSave = useSelector(state => userHasReadOnlyAccess(state, project));
+
+ return (
+
+
+
+ );
+}
diff --git a/frontend/src/features/datasets/SubjectSubform.js b/frontend/src/features/datasets/SubjectSubform.js
new file mode 100644
index 00000000..933a909e
--- /dev/null
+++ b/frontend/src/features/datasets/SubjectSubform.js
@@ -0,0 +1,78 @@
+import React,{ useEffect } from "react";
+import { useSelector, useDispatch } from "react-redux";
+import IconButton from "@mui/material/IconButton";
+import { useForm, useFormState } from "react-hook-form";
+import SaveIcon from "@mui/icons-material/Save";
+import AddIcon from "@mui/icons-material/Add";
+import DoneIcon from "@mui/icons-material/Done";
+import TableCell from "@mui/material/TableCell";
+import TableRow from "@mui/material/TableRow";
+
+import { FormCheckboxField, FormTextField } from "../forms/FormComponents";
+import { selectSubjectById, updateSubject } from "./subjectsSlice";
+import { selectDatasetProtocolById } from "../protocols/DatasetProtocols";
+
+export default function SubjectSubform({ subject, disableSave, dataset }) {
+ const dispatch = useDispatch();
+
+ const { control, handleSubmit, reset } = useForm({
+ defaultValues: {
+ id: subject.id,
+ display: subject.display,
+ name: subject.name,
+ shape: subject.shape,
+ },
+ });
+
+
+ const { isDirty } = useFormState({ control });
+
+ const onSubmit = (values) => {
+ console.log("submit subject", values);
+ dispatch(updateSubject(values));
+ };
+
+ useEffect(() => {
+ reset(subject);
+ }, [reset, subject]);
+
+ const protocol = dataset.protocols.find(p => p.id === subject.protocol)
+
+ return (
+
+
+ {subject.id_in_dataset}
+
+
+ {protocol?.name}
+
+
+
+
+
+
+ {isDirty && (
+
+
+ )}
+
+
+ );
+}
diff --git a/frontend/src/features/datasets/SubjectsTable.js b/frontend/src/features/datasets/SubjectsTable.js
new file mode 100644
index 00000000..e8a7ac20
--- /dev/null
+++ b/frontend/src/features/datasets/SubjectsTable.js
@@ -0,0 +1,80 @@
+import React, { useEffect } from "react";
+import { useSelector, useDispatch } from "react-redux";
+import Paper from "@mui/material/Paper";
+import Button from "@mui/material/Button";
+import IconButton from "@mui/material/IconButton";
+import { useForm, useFieldArray } from "react-hook-form";
+import makeStyles from '@mui/styles/makeStyles';
+import DeleteIcon from "@mui/icons-material/Delete";
+import AddIcon from "@mui/icons-material/Add";
+import Typography from "@mui/material/Typography";
+import Table from "@mui/material/Table";
+import TableBody from "@mui/material/TableBody";
+import TableCell from "@mui/material/TableCell";
+import TableContainer from "@mui/material/TableContainer";
+import TableHead from "@mui/material/TableHead";
+import TableRow from "@mui/material/TableRow";
+
+import { selectUnitById } from "../projects/unitsSlice";
+import { FormTextField, FormSelectField } from "../forms/FormComponents";
+import SubjectSubform from "./SubjectSubform";
+
+import { userHasReadOnlyAccess } from "../projects/projectsSlice";
+
+import { updateProtocol, deleteProtocol } from "../protocols/protocolsSlice.js";
+import { selectSubjectsByDataset } from "../datasets/subjectsSlice";
+
+const useStyles = makeStyles((theme) => ({
+ table: {
+ width: "100%",
+ },
+ tableCell: {
+ width: "100pt",
+ },
+ controls: {
+ display: "flex",
+ alignItems: "center",
+ paddingLeft: theme.spacing(1),
+ paddingBottom: theme.spacing(1),
+ "& > *": {
+ margin: theme.spacing(1),
+ },
+ },
+}));
+
+
+export default function SubjectsTable ({ dataset, disableSave }) {
+
+ const classes = useStyles();
+ const subjects = useSelector((state) => selectSubjectsByDataset(state, dataset));
+
+ return (
+
+ Subjects
+
+
+
+
+ Id
+ Protocol
+ Display
+ Shape
+ Actions
+
+
+
+ {subjects.map((subject, index) => (
+
+
+
+
+ )
+}
+
diff --git a/frontend/src/features/datasets/biomarkerTypesSlice.js b/frontend/src/features/datasets/biomarkerTypesSlice.js
new file mode 100644
index 00000000..1e8eb7ac
--- /dev/null
+++ b/frontend/src/features/datasets/biomarkerTypesSlice.js
@@ -0,0 +1,104 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+
+const biomarkerTypesAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = biomarkerTypesAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchBiomarkerType = createAsyncThunk(
+ "biomarkerTypes/fetchBiomarkerType",
+ async (biomarkerTypeId, { getState }) => {
+ const response = await api.get(`/api/biomarker_type/${biomarkerTypeId}/`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const fetchBiomarkerTypesByProject = createAsyncThunk(
+ "biomarkerTypes/fetchBiomarkerTypesByProject",
+ async (project_id, { getState }) => {
+ const response = await api.get(
+ `/api/biomarker_type/?project_id=${project_id}`, getState().login.csrf
+ );
+ return response;
+ }
+);
+
+export const fetchBiomarkerTypesByDataset = createAsyncThunk(
+ "subjects/fetchBiomarkerTypeByDataset",
+ async (dataset, { getState }) => {
+ const response = await api.get(
+ `/api/biomarker_type/`, getState().login.csrf,
+ dataset.biomarker_types
+ );
+ return response;
+ }
+);
+
+export const updateBiomarkerType = createAsyncThunk(
+ "biomarkerTypes/updateBiomarkerType",
+ async (biomarker_type, { getState }) => {
+ const response = await api.put(
+ `/api/biomarker_type/${biomarker_type.id}/`, getState().login.csrf,
+ biomarker_type
+ );
+ return response;
+ }
+);
+
+export const biomarkerTypesSlice = createSlice({
+ name: "biomarkerTypes",
+ initialState,
+ reducers: {
+ updateOne: biomarkerTypesAdapter.updateOne,
+ },
+ extraReducers: {
+ [fetchBiomarkerType.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchBiomarkerType.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchBiomarkerType.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ biomarkerTypesAdapter.addOne(state, action.payload);
+ },
+ [fetchBiomarkerTypesByProject.fulfilled]: biomarkerTypesAdapter.upsertMany,
+ [fetchBiomarkerTypesByDataset.fulfilled]: biomarkerTypesAdapter.upsertMany,
+ [updateBiomarkerType.fulfilled]: biomarkerTypesAdapter.upsertOne,
+ },
+});
+
+export const { updateOne: updateBiomarkerTypeById } =
+ biomarkerTypesSlice.actions;
+
+export default biomarkerTypesSlice.reducer;
+
+export const {
+ selectAll: selectAllBiomarkerTypes,
+ selectById: selectBiomarkerTypeById,
+ selectIds: selectBiomarkerTypeIds,
+} = biomarkerTypesAdapter.getSelectors((state) => state.biomarkerTypes);
+
+export const selectBiomarkerTypesByDatasetId = (state, id) => {
+ return selectAllBiomarkerTypes(state).filter((bd) => bd.dataset === id);
+};
+
+export const selectBiomarkerTypesByDatasetIds = (state, ids) => {
+ const datas = selectAllBiomarkerTypes(state).filter((bd) =>
+ ids.includes(bd.dataset)
+ );
+ return ids.reduce((sum, id) => {
+ sum[id] = datas.filter((bd) => bd.dataset === id);
+ return sum;
+ }, {});
+};
diff --git a/frontend/src/features/datasets/datasetsSlice.js b/frontend/src/features/datasets/datasetsSlice.js
new file mode 100644
index 00000000..8253927c
--- /dev/null
+++ b/frontend/src/features/datasets/datasetsSlice.js
@@ -0,0 +1,185 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { fetchBiomarkerTypesByProject, fetchBiomarkerTypesByDataset } from "./biomarkerTypesSlice";
+import { fetchSubjectByProject, fetchSubjectByDataset } from "./subjectsSlice";
+import { setSelected } from "../modelling/modellingSlice";
+import { api } from "../../Api";
+
+const datasetsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = datasetsAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchDatasets = createAsyncThunk(
+ "datasets/fetchDatasets",
+ async (project_id, { dispatch, getState }) => {
+ const response = await api.get(`/api/dataset/?project_id=${project_id}`, getState().login.csrf);
+
+ dispatch(fetchBiomarkerTypesByProject(project_id));
+ dispatch(fetchSubjectByProject(project_id));
+
+ return response;
+ }
+);
+
+export const fetchDatasetById = createAsyncThunk(
+ "datasets/fetchDatasetById",
+ async (datasetId, { dispatch, getState }) => {
+ dispatch(fetchBiomarkerTypesByDataset(datasetId));
+ dispatch(fetchSubjectByDataset(datasetId));
+ const response = await api.get(`/api/dataset/${datasetId}/`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const deleteDataset = createAsyncThunk(
+ "datasets/deleteDataset",
+ async (datasetId, { dispatch, getState }) => {
+ let { modelling } = getState()
+ if (modelling.selectedType === 'dataset' && modelling.selectedId === datasetId) {
+ await dispatch(setSelected({id: null, type: null}))
+ }
+ await api.delete(`/api/dataset/${datasetId}`, getState().login.csrf);
+ return datasetId;
+ }
+);
+
+export const addNewDataset = createAsyncThunk(
+ "datasets/addNewDataset",
+ async (project, { dispatch, getState }) => {
+ const initialDataset = {
+ name: "new",
+ project: project.id,
+ };
+ let dataset = await api.post("/api/dataset/", getState().login.csrf, initialDataset);
+ return dataset;
+ }
+);
+
+export const uploadDatasetCsv = createAsyncThunk(
+ "datasets/uploadDatasetCsv",
+ async ({ id, csv }, { dispatch, rejectWithValue, getState }) => {
+ try {
+ const dataset = await api
+ .putMultiPart(`/api/dataset/${id}/csv/`, getState().login.csrf, { csv })
+ await dispatch(fetchBiomarkerTypesByProject(dataset.project));
+ await dispatch(fetchSubjectByDataset(dataset));
+ return dataset;
+ } catch (err) {
+ return rejectWithValue(err)
+ }
+ }
+);
+
+export const updateDataset = createAsyncThunk(
+ "datasets/updateDataset",
+ async (dataset, { getState }) => {
+ const response = await api.put(`/api/dataset/${dataset.id}/`, getState().login.csrf, dataset);
+ return response;
+ }
+);
+
+export const datasetsSlice = createSlice({
+ name: "datasets",
+ initialState,
+ reducers: {
+ toggleDataset(state, action) {
+ let dataset = state.entities[action.payload.id];
+ dataset.chosen = !dataset.chosen;
+ },
+ setSelectDataset(state, action) {
+ console.log("setSelectDataset", action.payload)
+ let dataset = state.entities[action.payload.id];
+ dataset.selected = action.payload.select;
+ },
+ toggleProtocol(state, action) {
+ const dataset_id = action.payload.dataset
+ let dataset = state.entities[dataset_id];
+ let protocol = dataset.protocols.find(p => p.id === action.payload.id)
+ protocol.chosen = !protocol.chosen;
+ },
+ setSelectDatasetProtocol(state, action) {
+ const dataset_id = action.payload.dataset
+ let dataset = state.entities[dataset_id];
+ let protocol = dataset.protocols.find(p => p.id === action.payload.id)
+ protocol.select = action.payload.select;
+ },
+ toggleDisplayGroup(state, action) {
+ const group = action.payload.group;
+ const id = action.payload.id;
+ const displayGroups = state.entities[id].displayGroups;
+ console.log("toggleDisplayGroup", group, id, displayGroups);
+
+ let newDisplayGroups = displayGroups.filter((x) => x !== group);
+ if (newDisplayGroups.length === displayGroups.length) {
+ newDisplayGroups.push(group);
+ }
+ const changes = { displayGroups: newDisplayGroups };
+ datasetsAdapter.updateOne(state, { id, changes });
+ },
+ },
+ extraReducers: {
+ [fetchDatasets.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchDatasets.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchDatasets.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ datasetsAdapter.setAll(state, action.payload);
+ },
+ [fetchDatasetById.fulfilled]: datasetsAdapter.upsertOne,
+ [deleteDataset.fulfilled]: datasetsAdapter.removeOne,
+ [addNewDataset.fulfilled]: datasetsAdapter.addOne,
+ [updateDataset.fulfilled]: datasetsAdapter.upsertOne,
+ [uploadDatasetCsv.pending]: (state, action) => {
+ console.log("uploadcsv pending", action);
+ state.entities[action.meta.arg.id].status = "loading";
+ state.entities[action.meta.arg.id].errors = [];
+ },
+ [uploadDatasetCsv.rejected]: (state, action) => {
+ console.log("upload csv rejected", action);
+ state.entities[action.meta.arg.id].status = "rejected";
+ state.entities[action.meta.arg.id].errors = action.payload.csv;
+ },
+ [uploadDatasetCsv.fulfilled]: (state, action) => {
+ console.log("uploadcsv fulfilled", action);
+ state.entities[action.meta.arg.id].status = "succeeded";
+ datasetsAdapter.upsertOne(state, action);
+ },
+ },
+});
+
+export const { toggleDataset, toggleProtocol, setSelectDataset, toggleDisplayGroup: toggleDatasetDisplayGroup } =
+ datasetsSlice.actions;
+
+export default datasetsSlice.reducer;
+
+export const {
+ selectAll: selectAllDatasets,
+ selectById: selectDatasetById,
+ selectIds: selectDatasetIds,
+} = datasetsAdapter.getSelectors((state) => state.datasets);
+
+export const selectChosenDatasets = (state) =>
+ selectAllDatasets(state).filter((dataset) => dataset.chosen);
+
+
+export const selectChosenDatasetProtocols = (state) =>
+ selectAllDatasets(state).reduce((sum, dataset) => {
+ return sum.concat(dataset.protocols.filter(p => p.chosen))
+ }, []);
+
+export const selectAllProtocols = (state) =>
+ selectAllDatasets(state).reduce((sum, dataset) => {
+ return sum.concat(dataset.protocols)
+ }, []);
diff --git a/frontend/src/features/datasets/subjectsSlice.js b/frontend/src/features/datasets/subjectsSlice.js
new file mode 100644
index 00000000..6757aacf
--- /dev/null
+++ b/frontend/src/features/datasets/subjectsSlice.js
@@ -0,0 +1,94 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+
+const subjectsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = subjectsAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchSubject = createAsyncThunk(
+ "subjects/fetchSubject",
+ async (subjectId, { getState }) => {
+ console.log("fetchSubject", subjectId);
+ const response = await api.get(`/api/subject/${subjectId}/`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const updateSubject = createAsyncThunk(
+ "subjects/updateSubject",
+ async (subject, {dispatch, getState}) => {
+ const response = await api.put(`/api/subject/${subject.id}/`, getState().login.csrf, subject);
+ return response;
+ }
+);
+
+export const fetchSubjectByProject = createAsyncThunk(
+ "subjects/fetchSubjectByProject",
+ async (project_id, { getState }) => {
+ const response = await api.get(`/api/subject/?project_id=${project_id}`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const fetchSubjectByDataset = createAsyncThunk(
+ "subjects/fetchSubjectByDataset",
+ async (dataset, { getState }) => {
+ const response = await api.get(`/api/subject/`, dataset.subjects);
+ return response;
+ }
+);
+
+export const subjectsSlice = createSlice({
+ name: "subjects",
+ initialState,
+ reducers: {},
+ extraReducers: {
+ [fetchSubject.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchSubject.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchSubject.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ subjectsAdapter.addOne(state, action.payload);
+ },
+ [fetchSubjectByProject.fulfilled]: subjectsAdapter.upsertMany,
+ [fetchSubjectByDataset.fulfilled]: subjectsAdapter.upsertMany,
+ [updateSubject.fulfilled]: subjectsAdapter.upsertOne,
+ },
+});
+
+export const {
+ setDisplayGroups: setSubjectDisplayGroups,
+ toggleDisplayGroup: toggleSubjectDisplayGroup,
+} = subjectsSlice.actions;
+
+export default subjectsSlice.reducer;
+
+export const {
+ selectAll: selectAllSubjects,
+ selectById: selectSubjectById,
+ selectIds: selectSubjectIds,
+} = subjectsAdapter.getSelectors((state) => state.subjects);
+
+export const selectSubjectDisplayGroups = (state) => {
+ return state.subjects.displayGroups;
+};
+
+export const selectSubjectsByDataset = (state, dataset) => {
+ return selectAllSubjects(state).filter((subject) => subject.dataset === dataset.id);
+};
+export const selectSubjectsByIds = (state, ids) => {
+ return ids.map(id => state.subjects.entities[id])
+}
diff --git a/frontend/src/features/forms/ComponentForm.js b/frontend/src/features/forms/ComponentForm.js
new file mode 100644
index 00000000..99f8bb54
--- /dev/null
+++ b/frontend/src/features/forms/ComponentForm.js
@@ -0,0 +1,67 @@
+import React from "react";
+import Grid from "@mui/material/Grid";
+import Typography from "@mui/material/Typography";
+import makeStyles from '@mui/styles/makeStyles';
+import List from "@mui/material/List";
+import ListItem from "@mui/material/ListItem";
+
+import MathJaxPreview from "react-mathjax-preview";
+
+import VariableSubform from "../variables/VariableSubform";
+import OutputSubform from "../variables/OutputSubform";
+
+export default function ComponentForm({ control, component, disableSave }) {
+
+ const mathjaxConfig = {
+ CommonHTML: { linebreaks: { automatic: true } },
+ SVG: { linebreaks: { automatic: true } },
+ "HTML-CSS": { linebreaks: { automatic: true } },
+ };
+ const sortedVariables = [...component.variables].sort();
+ const sortedStates = [...component.states].sort();
+ const sortedOutputs = [...component.outputs].sort();
+
+ return (
+
+
+
+ Variables
+
+ {sortedVariables.map((variable, index) => {
+ return (
+
+
+ );
+ })}
+
+
+
+ Initial Conditions
+
+ {sortedStates.map((state, index) => {
+ return (
+
+
+ );
+ })}
+
+
+
+ Outputs
+
+ {sortedOutputs.map((output, index) => {
+ return (
+
+
+ );
+ })}
+
+
+ );
+}
diff --git a/frontend/src/features/forms/FormComponents.js b/frontend/src/features/forms/FormComponents.js
new file mode 100644
index 00000000..6f09539e
--- /dev/null
+++ b/frontend/src/features/forms/FormComponents.js
@@ -0,0 +1,467 @@
+import React from "react";
+import TextField from "@mui/material/TextField";
+
+import makeStyles from '@mui/styles/makeStyles';
+import InputLabel from "@mui/material/InputLabel";
+import Tooltip from "@mui/material/Tooltip";
+import MenuItem from "@mui/material/MenuItem";
+import Typography from "@mui/material/Typography";
+import FormControl from "@mui/material/FormControl";
+import FormHelperText from "@mui/material/FormHelperText";
+import Slider from "@mui/material/Slider";
+import ListSubheader from "@mui/material/ListSubheader";
+import Button from "@mui/material/Button";
+import Select from "@mui/material/Select";
+import { Controller } from "react-hook-form";
+import { DateTimePicker } from "@mui/x-date-pickers/DateTimePicker";
+
+import OutlinedInput from "@mui/material/OutlinedInput";
+import Stack from "@mui/material/Stack";
+import Chip from "@mui/material/Chip";
+import Checkbox from "@mui/material/Checkbox";
+import FormControlLabel from "@mui/material/FormControlLabel";
+import Box from "@mui/material/Box";
+
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+
+dayjs.extend(utc);
+
+const useStyles = makeStyles((theme) => ({
+ container: {
+ paddingTop: theme.spacing(4),
+ paddingBottom: theme.spacing(4),
+ height: "100%",
+ },
+ formInput: {
+ display: "flex",
+ margin: theme.spacing(1),
+ },
+ chips: {
+ display: "flex",
+ flexWrap: "wrap",
+ },
+ chip: {
+ margin: 2,
+ },
+ fileFieldBox: {
+ margin: theme.spacing(1),
+ width: "200pt",
+ display: "inline-block",
+ },
+ fileFieldField: {
+ "& .MuiFormLabel-root.Mui-disabled": {
+ color: theme.palette.text.secondary,
+ },
+ },
+ fileFieldButton: {
+ width: "100%",
+ height: "100%",
+ overflow: "hidden",
+ },
+}));
+
+export function FormCheckboxField({
+ control,
+ name,
+ defaultValue,
+ label,
+ ...rest
+}) {
+ return (
+
+ (
+ {
+ onChange(e);
+ }}
+ checked={value}
+ inputRef={ref}
+ {...rest}
+ />
+ }
+ label={label}
+ />
+ )}
+ />
+
+ );
+}
+
+export function FormSliderField({
+ control,
+ name,
+ defaultValue,
+ min,
+ label_min,
+ label_max,
+ max,
+ log,
+ label,
+ tooltip,
+}) {
+ const roundNumber = (x) => {
+ if (x === 0 || x === 0.0) {
+ return x;
+ } else if (Math.abs(x) < 0.01 || Math.abs(x) >= 1000.0) {
+ const [coefficient, exponent] = x
+ .toExponential()
+ .split("e")
+ .map((item) => Number(item));
+ return `${Math.round(coefficient)}e^${exponent}`;
+ } else if (Math.abs(x) >= 100.0) {
+ return x.toFixed(0);
+ } else if (Math.abs(x) >= 10.0) {
+ return x.toFixed(1);
+ } else {
+ return x.toFixed(2);
+ }
+ };
+
+
+ let calculateValue = (value) => value;
+ if (log) {
+ calculateValue = (value) => Math.exp(value);
+ }
+
+ const marks = [
+ label_min ? {
+ value: min,
+ label: label_min,
+ } :
+ {
+ value: min,
+ },
+ label_max ? {
+ value: max,
+ label: label_max,
+ } :
+ {
+ value: max,
+ },
+
+ ]
+
+ const internalMin = log ? Math.log(min) : min;
+ const internalMax = log ? Math.log(max) : max;
+ const internalStep = log ? (Math.log(max) - Math.log(min)) / 100.0 : (max - min) / 100.0;
+
+ return (
+
+ {label && (
+
+
+ {label}
+
+
+ )}
+ {
+ return (
+ {
+ e.target.name = name;
+ e.target.value = v;
+ onChange(e);
+ }}
+ onBlur={(e, v) => {
+ e.target.name = name;
+ e.target.value = v;
+ onBlur(e);
+ }}
+ aria-labelledby={`input-slider-${name}`}
+ />
+ );
+ }}
+ />
+
+ );
+}
+
+export function FormDateTimeField({
+ control,
+ name,
+ defaultValue,
+ label,
+ ...rest
+}) {
+ return (
+ (
+ {
+ const handleChange = (event) => {
+ clearErrors(name);
+ const files = Array.from(event.target.files);
+ const [file] = files;
+ if (!!onChange) onChange({ target: { value: file } });
+ };
+ return (
+
+
+
+
+
+
+
+ );
+ }}
+ />
+ );
+}
+
+export function FormTextField({ control, name, defaultValue, label, ...rest }) {
+ return (
+
+ (
+
+ );
+}
+
+export function FormMultiSelectField({
+ control,
+ name,
+ defaultValue,
+ label,
+ options,
+ ...rest
+}) {
+ return (
+
+
+ {label}
+ (
+
+ {selected.map((value) => {
+ const option_list = options.filter((x) => x.value === value);
+ let option = {
+ key: "user not found",
+ value: 0,
+ };
+ if (option_list.length > 0) {
+ option = option_list[0];
+ }
+ return (
+
+ )}
+ {...rest}
+ {...field}
+ >
+ {options.map((option) => {
+ return (
+
+ {option.key}
+
+ );
+ })}
+
+ )}
+ />
+
+
+ );
+}
+
+export function FormSelectField({
+ control,
+ name,
+ defaultValue,
+ label,
+ options,
+ displayEmpty,
+ useGroups,
+ onChangeUser,
+ ...rest
+}) {
+ let groups = {};
+ if (useGroups) {
+ for (const option of options) {
+ if (!(option.group in groups)) {
+ groups[option.group] = [];
+ }
+ groups[option.group].push(option);
+ }
+ }
+ return (
+
+
+ {label}
+ {
+ const inputEl = document.querySelector(`input[name="${name}"]`);
+ inputEl.focus();
+ }}
+ render={({
+ field: { onChange, onBlur, value, name, ref },
+ fieldState: { invalid, isTouched, isDirty, error },
+ formState,
+ }) => {
+ console.log("error in select", error);
+ return (
+
+ {group} ,
+ groups[group].map((option, j) => {
+ return (
+
+ {option.key}
+
+ );
+ }),
+ ])
+ : options.map((option, i) => (
+
+ {option.key}
+
+ ))}
+
+ {error?.message &&
+ {error?.message}
+ }
+
+ )
+ }
+ }
+ />
+
+
+
+
+
+
+
+
+
+
+
+
+
+ );
+}
+
diff --git a/frontend/src/features/inference/InferenceChart.js b/frontend/src/features/inference/InferenceChart.js
new file mode 100644
index 00000000..6544dc98
--- /dev/null
+++ b/frontend/src/features/inference/InferenceChart.js
@@ -0,0 +1,163 @@
+import React, { useState, useEffect } from "react";
+import PropTypes from 'prop-types';
+import Tab from '@mui/material/Tab';
+import Typography from '@mui/material/Typography';
+import Tabs from '@mui/material/Tabs';
+import Box from '@mui/material/Box';
+import Button from '@mui/material/Button';
+import Alert from '@mui/material/Alert';
+import Stack from '@mui/material/Stack';
+import { useSelector, useDispatch } from "react-redux";
+import InferenceChartOptimisationResults from './InferenceChartOptimisationResults'
+import InferenceChartSamplingResults from './InferenceChartSamplingResults'
+import InferenceChartTraces from './InferenceChartTraces'
+import InferenceChartFits from './InferenceChartFits'
+import { fetchChainsByInferenceId } from "../inference/chainSlice";
+import { fetchInferenceById } from "../inference/inferenceSlice";
+
+import {selectChainsByInferenceId} from './chainSlice'
+import {selectAlgorithmById} from './algorithmsSlice'
+
+
+import {
+ selectVariablesByPdModel,
+ selectVariablesByDosedPkModel,
+} from "../variables/variablesSlice";
+
+
+function TabPanel(props) {
+ const { children, value, index, ...other } = props;
+
+ return (
+
+ {value === index && (
+
+ {children}
+
+ )}
+
+ );
+}
+
+TabPanel.propTypes = {
+ children: PropTypes.node,
+ index: PropTypes.number.isRequired,
+ value: PropTypes.number.isRequired,
+};
+
+export default function InferenceChart({inference}) {
+ const [value, setValue] = useState(0);
+ const dispatch = useDispatch();
+
+ const chains = useSelector((state) =>
+ selectChainsByInferenceId(state, inference.id)
+ );
+
+
+ const priorsWithChainValues = inference.log_likelihoods.filter(
+ ll => ll.is_a_prior
+ ).map(ll => ({
+ ...ll,
+ chains: chains.map(chain => chain.data.chain[ll.id] || {
+ iterations: [], values: [],
+ }),
+ kdes: chains.map(chain => chain.data.kde[ll.id] || {
+ densities: [], values: [],
+ }),
+ }));
+
+ const observedWithChainValues = inference.log_likelihoods.filter(
+ ll => ll.observed
+ ).map(ll => {
+ const model_loglikelihoods = inference.log_likelihoods.filter(cll =>
+ ll.children.includes(cll.id)
+ )
+ return {
+ ...ll,
+ model_loglikelihoods,
+ outputs: chains.map(chain => chain.outputs[ll.id] || {
+ times: [], datas: [], percentile_mins: [], percentile_maxs: [],
+ medians: [], subjects: [],
+ })
+ }
+ });
+ console.log('chains', chains)
+
+ const algorithm = useSelector((state) =>
+ selectAlgorithmById(state, inference.algorithm)
+ )
+
+ const isSampling = algorithm.category === "SA"
+
+ const optimisationTabs = [
+ //{ label: 'Fit', component: InferenceChartFit },
+ { label: 'Traces', component: InferenceChartTraces },
+ { label: 'Fits', component: InferenceChartFits },
+ { label: 'Results', component: InferenceChartOptimisationResults },
+ ]
+ const samplingTabs = [
+ //{ label: 'PosteriorPredictive', component: InferenceChartPosteriorPredictive },
+ //{ label: 'Biplot', component: InferenceChartBiplot},
+ { label: 'Traces', component: InferenceChartTraces },
+ { label: 'Fits', component: InferenceChartFits },
+ { label: 'Results', component: InferenceChartSamplingResults },
+ ]
+ const tabs = isSampling ? samplingTabs : optimisationTabs
+
+ const handleChange = (event, newValue) => {
+ setValue(newValue);
+ };
+
+ const handleRefresh = () => {
+ dispatch(fetchChainsByInferenceId(inference.id));
+ dispatch(fetchInferenceById(inference.id));
+ }
+
+ const noData = chains.length === 0
+
+ return (
+
+
+
+ Refresh
+
+
+ { noData &&
+ No data, refresh to get chain data
+ }
+
+
+
+ { tabs.map(tab => (
+
+
+ { tabs.map((tab, index) => (
+
+
+ ))}
+
+
+ )
+}
diff --git a/frontend/src/features/inference/InferenceChartFits.js b/frontend/src/features/inference/InferenceChartFits.js
new file mode 100644
index 00000000..2b948ba1
--- /dev/null
+++ b/frontend/src/features/inference/InferenceChartFits.js
@@ -0,0 +1,283 @@
+import React from "react";
+import { useSelector } from "react-redux";
+import Grid from "@mui/material/Grid";
+
+import makeStyles from '@mui/styles/makeStyles';
+import iqr from 'compute-iqr'
+
+import { Scatter } from "react-chartjs-2";
+
+import FormControl from "@mui/material/FormControl";
+import MenuItem from "@mui/material/MenuItem";
+import InputLabel from "@mui/material/InputLabel";
+import Select from "@mui/material/Select";
+
+import { Chart, registerables, Interaction } from "chart.js";
+import { CrosshairPlugin, Interpolate } from "chartjs-plugin-crosshair";
+import { getColor, getColorBackground } from "../modelling/ShapesAndColors";
+import { selectSubjectsByIds } from "../datasets/subjectsSlice";
+import {
+ selectVariableById,
+} from "../variables/variablesSlice";
+import {
+ selectUnitById,
+} from "../projects/unitsSlice";
+
+
+Chart.register(...registerables, CrosshairPlugin);
+Interaction.modes.interpolate = Interpolate;
+
+const useStyles = makeStyles((theme) => ({
+ root: {
+ width: "100%",
+ },
+ plot: {
+ height: "40vh",
+ width: "100%",
+ },
+}));
+
+
+
+function InferenceChartFits({ inference, observed }) {
+ // TODO: assumes a single log likelihood
+ //
+ const classes = useStyles();
+
+ const has_distribution = true
+ const times = observed.outputs ? observed.outputs[0].times : []
+ const datas = observed.outputs ? observed.outputs[0].datas : []
+
+ const outputVariable = useSelector((state) => {
+ return selectVariableById(state, observed.parameters[0].variable);
+ });
+ const timeVariable = useSelector((state) => {
+ return selectVariableById(state, observed.model_loglikelihoods[0].time_variable);
+ });
+ const outputUnit = useSelector((state) => {
+ if (outputVariable) {
+ return selectUnitById(state, outputVariable.unit)
+ }
+ });
+ const timeUnit = useSelector((state) => {
+ if (timeVariable) {
+ return selectUnitById(state, timeVariable.unit)
+ }
+ });
+
+ const yLabelUnit = outputUnit ? outputUnit.symbol : ''
+ const yLabelName = outputVariable ? outputVariable.name : ''
+ const xLabelUnit = timeUnit ? timeUnit.symbol : ''
+ const xLabelName = timeVariable ? timeVariable.name : ''
+ const yLabel = `${yLabelName} [${yLabelUnit}]`
+ const xLabel = `${xLabelName} [${xLabelUnit}]`
+
+ // TODO: assume single output
+ let data = {
+ }
+ if (has_distribution) {
+ data['datasets'] = observed.outputs.map((outputs, i) => {
+ const color = getColor(i);
+ const backgroundColor = getColorBackground(i);
+ return [
+ {
+ type: "line",
+ label: `chain ${i}: 10% percentile`,
+ fill: false,
+ borderColor: color,
+ borderWidth: 0,
+ pointRadius: 0,
+ backgroundColor: backgroundColor,
+ lineTension: 0,
+ interpolate: true,
+ data: outputs.percentile_mins.map((y, i) => ({ x: times[i], y: y }))
+ },
+ {
+ type: "line",
+ label: `chain ${i}: 90% percentile`,
+ borderColor: color,
+ borderWidth: 0,
+ backgroundColor: backgroundColor,
+ pointRadius: 0,
+ fill: '-1',
+ lineTension: 0,
+ interpolate: true,
+ data: outputs.percentile_maxs.map((y, i) => ({ x: times[i], y: y }))
+ },
+ {
+ type: "line",
+ label: `chain ${i}: median`,
+ borderColor: color,
+ borderWidth: 2.5,
+ pointRadius: 0,
+ backgroundColor: backgroundColor,
+ fill: false,
+ lineTension: 0,
+ interpolate: true,
+ data: outputs.medians.map((y, i) => ({ x: times[i], y: y }))
+ },
+ ]
+ }).concat([
+ {
+ type: "line",
+ label: 'data',
+ borderColor: 'black',
+ borderWidth: 2.5,
+ backgroundColor: 'black',
+ showLine: false,
+ data: datas.map((y, i) => ({ x: times[i], y: y }))
+ },
+ ]).flat()
+
+ } else {
+ data['datasets'] = observed.outputs.map((outputs, i) => {
+ const color = getColor(i);
+ const backgroundColor = getColorBackground(i);
+ return {
+ type: "line",
+ label: `chain ${i}: final fit`,
+ borderColor: color,
+ borderWidth: 2.5,
+ pointRadius: 0,
+ backgroundColor: backgroundColor,
+ lineTension: 0,
+ interpolate: true,
+ data: outputs.medians.map((y, i) => ({ x: times[i], y: y }))
+ }
+ }).concat([
+ {
+ type: "line",
+ label: 'data',
+ borderColor: 'black',
+ backgroundColor: 'black',
+ borderWidth: 2.5,
+ showLine: false,
+ data: datas.map((y, i) => ({ x: times[i], y: y }))
+ },
+ ])
+ }
+
+ let options = {
+ animation: {
+ duration: 0,
+ },
+ responsive: true,
+ maintainAspectRatio: false,
+ scales: {
+ x: {
+ type: "linear",
+ title: {
+ text: xLabel,
+ display: true,
+ },
+ },
+ y: {
+ position: "left",
+ title: {
+ text: yLabel,
+ display: true,
+ },
+ },
+ },
+ plugins: {
+ legend: {
+ labels: {
+ boxHeight: 1
+ },
+ },
+ title: {
+ display: true,
+ text: observed.name,
+ },
+ tooltip: {
+ mode: "interpolate",
+ intersect: false,
+ callbacks: {
+ title: function (a, d) {
+ return a[0].element.x.toPrecision(4);
+ },
+ label: function (d) {
+ return d.dataset.label + ": " + d.element.y.toPrecision(4);
+ },
+ },
+ },
+ crosshair: {
+ sync: {
+ enabled: false,
+ },
+ },
+ },
+ };
+
+ return (
+
+
+ );
+}
+
+
+function InferenceChartTracesObserved({ inference, observed}) {
+
+ const subjectIds = observed.outputs ? observed.outputs[0].subjects : []
+ const uniqueSubjectsIds = [...new Set(subjectIds)]
+ const [subjectIndex, setSubjectIndex] = React.useState(0);
+ const subjects = useSelector((state) => selectSubjectsByIds(state, uniqueSubjectsIds));
+ const multiple_subjects = uniqueSubjectsIds.length > 1
+ const subjectOptions = multiple_subjects ?
+ subjects.map((s, i) => ({label: s.id_in_dataset, value: i})) : []
+ const observedFiltered = multiple_subjects ? {
+ ...observed,
+ outputs: observed.outputs.map(outputs => ({
+ ...outputs,
+ percentile_mins: outputs.percentile_mins.filter((_, i) => subjectIds[i] === uniqueSubjectsIds[subjectIndex]),
+ percentile_maxs: outputs.percentile_maxs.filter((_, i) => subjectIds[i] === uniqueSubjectsIds[subjectIndex]),
+ medians: outputs.medians.filter((_, i) => subjectIds[i] === uniqueSubjectsIds[subjectIndex]),
+ datas: outputs.datas.filter((_, i) => subjectIds[i] === uniqueSubjectsIds[subjectIndex]),
+ times: outputs.times.filter((_, i) => subjectIds[i] === uniqueSubjectsIds[subjectIndex]),
+ }))
+ } : observed
+
+ const handleSubjectChange = (event) => {
+ setSubjectIndex(event.target.value);
+ };
+
+ return (
+
+ { multiple_subjects &&
+
+ Subject
+
+ {subjectOptions.map(so => (
+ {so.label}
+ ))}
+
+
+ }
+
+
+
+ )
+}
+
+
+export default function InferenceChartTraces({ inference, observedWithChainValues}) {
+ const classes = useStyles();
+
+ return (
+
+
+ {observedWithChainValues.map(observed => (
+
+ ))}
+
+
+ )
+}
diff --git a/frontend/src/features/inference/InferenceChartOptimisationResults.js b/frontend/src/features/inference/InferenceChartOptimisationResults.js
new file mode 100644
index 00000000..18d31da5
--- /dev/null
+++ b/frontend/src/features/inference/InferenceChartOptimisationResults.js
@@ -0,0 +1,74 @@
+import React from "react";
+import { useSelector } from "react-redux";
+import makeStyles from '@mui/styles/makeStyles';
+import Typography from "@mui/material/Typography";
+import Table from "@mui/material/Table";
+import TableBody from "@mui/material/TableBody";
+import TableCell from "@mui/material/TableCell";
+import TableContainer from "@mui/material/TableContainer";
+import TableHead from "@mui/material/TableHead";
+import TableRow from "@mui/material/TableRow";
+
+import {
+ selectVariablesByPdModel,
+ selectVariablesByDosedPkModel,
+} from "../variables/variablesSlice";
+
+
+
+const useStyles = makeStyles((theme) => ({
+ root: {
+ height: "85vh",
+ width: "100%",
+ },
+}));
+
+export default function InferenceChartOptimisationResults({ inference, priorsWithChainValues }) {
+ const classes = useStyles();
+
+ const rows = priorsWithChainValues.map(prior => {
+ const final_values = prior.chains.map(chain => chain.values[chain.values.length - 1].toFixed(2))
+ return {
+ name: prior.name,
+ final_values,
+ }
+ });
+
+ return (
+
+
+ Number of iterations: {inference.number_of_iterations} / {inference.max_number_of_iterations}
+
+
+ Number of function evaluations: {inference.number_of_function_evals}
+
+
+
+
+
+ Variable
+ { Array(inference.number_of_chains).fill().map((_, i) => (
+ {`Final ${i}`}
+ ))}
+
+
+
+ {rows.map((row) => (
+
+
+ {row.name}
+
+ { Array(inference.number_of_chains).fill().map((_, i) => (
+ {row.final_values[i]}
+ ))}
+
+ ))}
+
+
+
+
+
+ Number of iterations: {inference.number_of_iterations} / {inference.max_number_of_iterations}
+
+
+ Number of function evaluations: {inference.number_of_function_evals}
+
+
+ Number of chains: {inference.number_of_chains}
+
+
+
+
+
+
+ Variable
+ Samples
+ Mean
+ Std Dev
+
+
+
+ {rows.map((row) => (
+
+
+ {row.name}
+
+ {row.number_of_samples}
+ {row.mean}
+ {row.stddev}
+
+ ))}
+
+
+
+
+
+ );
+}
+
+function InferenceChartTrace({ prior }) {
+ const classes = useStyles();
+
+ const data = {
+ datasets: prior.chains.map((chain, index) => {
+ const color = getColor(prior.id);
+ const data = chain ?
+ chain.values.map((y, i) => ({ x: chain.iterations[i], y: y })) :
+ { x : null, y: null }
+ return {
+ type: "line",
+ label: `Chain ${index}`,
+ borderColor: color,
+ backgroundColor: color,
+ showLine: true,
+ pointRadius: 0,
+ fill: false,
+ borderWidth: 1.5,
+ lineTension: 0,
+ interpolate: true,
+ data: data,
+ };
+ })
+ }
+ let options = {
+ animation: {
+ duration: 0,
+ },
+ responsive: true,
+ maintainAspectRatio: false,
+ scales: {
+ x: {
+ type: "linear",
+ title: {
+ text: "Iteration",
+ display: true,
+ },
+ },
+ y: {
+ position: "left",
+ title: {
+ text: prior.name,
+ display: true,
+ },
+ },
+ },
+ plugins: {
+ decimation: {
+ enabled: true,
+ algorithm: 'lttb',
+ },
+ legend: {
+ labels: {
+ boxHeight: 1
+ },
+ },
+ tooltip: {
+ mode: "interpolate",
+ callbacks: {
+ title: function (a, d) {
+ return a[0].element.x.toPrecision(4);
+ },
+ label: function (d) {
+ return d.dataset.label + ": " + d.element.y.toPrecision(4);
+ },
+ },
+ },
+ crosshair: false,
+ },
+ };
+
+ return (
+
+
+ );
+}
+
+function InferenceChartFunction({ chains }) {
+ const classes = useStyles();
+
+ const data = {
+ datasets: chains.map((chain, index) => {
+ const color = getColor(index);
+ const data = chain ?
+ chain.data.function.values.map((y, i) => ({ x: chain.data.function.iterations[i], y: y })) :
+ { x : null, y: null }
+ return {
+ type: "line",
+ label: `Chain ${index}`,
+ borderColor: color,
+ backgroundColor: color,
+ showLine: true,
+ pointRadius: 0,
+ fill: false,
+ borderWidth: 1.5,
+ lineTension: 0,
+ interpolate: true,
+ data: data,
+ };
+ })
+ }
+ let options = {
+ animation: {
+ duration: 0,
+ },
+ responsive: true,
+ maintainAspectRatio: false,
+ scales: {
+ x: {
+ type: "linear",
+ title: {
+ text: "Iteration",
+ display: true,
+ },
+ },
+ y: {
+ position: "left",
+ title: {
+ text: "Log-likelihood",
+ display: true,
+ },
+ },
+ },
+ plugins: {
+ decimation: {
+ enabled: true,
+ algorithm: 'lttb',
+ },
+ legend: {
+ labels: {
+ boxHeight: 1
+ },
+ },
+ tooltip: {
+ mode: "interpolate",
+ callbacks: {
+ title: function (a, d) {
+ return a[0].element.x.toPrecision(4);
+ },
+ label: function (d) {
+ return d.dataset.label + ": " + d.element.y.toPrecision(4);
+ },
+ },
+ },
+ crosshair: false,
+ },
+ };
+
+ return (
+
+
+ );
+}
+
+
+function InferenceChartTracesPrior({ prior }) {
+ console.log('prior', prior)
+ const multiple_subjects = prior.chains.length !== 0 && !('values' in prior.chains[0])
+ const subjectIds = multiple_subjects ? Object.keys(prior.chains[0]) : []
+ const subjects = useSelector((state) => selectSubjectsByIds(state, subjectIds));
+ const [subjectIndex, setSubjectIndex] = React.useState(0);
+ const subjectOptions = subjects.map((s, i) => ({label: s.id_in_dataset, value: i}))
+ const chosenSubject = subjects && subjectIndex ? subjects[subjectIndex] : null
+ console.log('subjects', multiple_subjects, subjectIds, subjects, chosenSubject)
+ let priorForSubject = prior
+ if (multiple_subjects) {
+ if (chosenSubject) {
+ priorForSubject = {
+ ...prior,
+ chains: prior.chains.map(chain => chain[chosenSubject.id]) ,
+ kdes: prior.kdes.map(kde => kde[chosenSubject.id]),
+ }
+ } else {
+ const firstKey = Object.keys(prior.chains[0])[0]
+ priorForSubject = {
+ ...prior,
+ chains: prior.chains.map(chain => chain[firstKey]) ,
+ kdes: prior.kdes.map(kde => kde[firstKey]),
+ }
+ }
+ }
+
+ const handleSubjectChange = (event) => {
+ setSubjectIndex(event.target.value);
+ };
+
+ return (
+
+
+ {multiple_subjects &&
+
+ Subject
+
+ {subjectOptions.map(so => (
+ {so.label}
+ ))}
+
+
+ }
+
+
+
+
+
+ )
+}
+
+export default function InferenceChartTraces({ inference, priorsWithChainValues, chains }) {
+ const classes = useStyles();
+
+ return (
+
+
+
+
+ {priorsWithChainValues.map(prior => (
+
+
+ )
+}
diff --git a/frontend/src/features/inference/InferenceDetail.js b/frontend/src/features/inference/InferenceDetail.js
new file mode 100644
index 00000000..6c59e533
--- /dev/null
+++ b/frontend/src/features/inference/InferenceDetail.js
@@ -0,0 +1,422 @@
+import React, { useEffect, useState, useMemo, useCallback } from "react";
+import { useSelector } from "react-redux";
+import { useDispatch } from "react-redux";
+import Divider from '@mui/material/Divider';
+import Button from "@mui/material/Button";
+
+import { useHistory } from "react-router-dom";
+import Grid from "@mui/material/Grid";
+import Paper from "@mui/material/Paper";
+
+import FormControl from "@mui/material/FormControl";
+import ReactFlow, { MarkerType, applyEdgeChanges, applyNodeChanges } from 'react-flow-renderer';
+import Stack from "@mui/material/Stack";
+import * as ELK from 'elkjs';
+import InputLabel from "@mui/material/InputLabel";
+import Alert from '@mui/material/Alert';
+import { useForm, useFieldArray } from "react-hook-form";
+import makeStyles from '@mui/styles/makeStyles';
+import Typography from "@mui/material/Typography";
+import List from "@mui/material/List";
+import ListItem from "@mui/material/ListItem";
+import Tooltip from "@mui/material/Tooltip";
+import Select from "@mui/material/Select";
+import IconButton from "@mui/material/IconButton";
+import MenuItem from "@mui/material/MenuItem";
+import AddIcon from "@mui/icons-material/Add";
+import DeleteIcon from "@mui/icons-material/Delete";
+
+
+import InferenceDialog from "./InferenceDialog";
+
+import { selectWritablePkModels, selectReadOnlyPkModels } from "../pkModels/pkModelsSlice";
+import { selectWritablePdModels, selectReadOnlyPdModels } from "../pdModels/pdModelsSlice";
+import { selectAllAlgorithms } from "../inference/algorithmsSlice";
+
+import {
+ selectBiomarkerTypesByDatasetId,
+ selectBiomarkerTypeById,
+} from "../datasets/biomarkerTypesSlice";
+
+import {
+ selectVariablesByPdModel,
+ selectVariablesByDosedPkModel,
+ selectVariableById,
+} from "../variables/variablesSlice";
+
+import { selectAllDatasets } from "../datasets/datasetsSlice";
+
+import { updateInference, deleteInference, selectAllInferences } from "../inference/inferenceSlice";
+import { runInference, stopInference } from "./inferenceSlice";
+import { FormTextField, FormSelectField, FormSliderField } from "../forms/FormComponents";
+import { userHasReadOnlyAccess } from "../projects/projectsSlice";
+
+const elk = new ELK()
+
+export default function InferenceDetail({ project, inference }) {
+ const dispatch = useDispatch();
+ let history = useHistory();
+ const [openDialog, setOpenDialog] = React.useState(false);
+ const handleCloseDialog = () => {
+ setOpenDialog(false);
+ };
+ const handleEdit = () => {
+ setOpenDialog(true);
+ };
+
+ let logLikelihoodNodes = inference.log_likelihoods.map(ll => {
+ let label = (<>{ll.name})
+ let border = 'solid';
+ let width = 140;
+ let height = 40;
+ let type = 'default';
+ let observed = '';
+ if (ll.observed) {
+ observed = 'Observed '
+ type = 'input'
+ }
+ if (ll.form === 'F') {
+ type = 'output'
+ }
+ if (ll.form === 'M') {
+ label = (<>Model: {ll.name});
+ border = '5px double';
+ height = 2 * height;
+ } else if (ll.form === 'N') {
+ label = (<>{observed}Normal );
+ } else if (ll.form === 'LN') {
+ label = (<>{observed}LogNormal );
+ } else if (ll.form === 'U') {
+ label = (<>{observed}Uniform );
+ } else if (ll.form === 'F') {
+ label = `${ll.value}`
+ width = 0.6 * width;
+ }
+ return {
+ id: `${ll.id}`,
+ data: { label },
+ position: { x: 0, y: 0 },
+ type,
+ style: {
+ background: '#D6D5E6',
+ color: '#333',
+ border,
+ width,
+ height,
+ },
+ }
+ });
+
+ const parameterEdges = inference.log_likelihoods.reduce((sum, ll) =>
+ sum.concat(ll.parameters.map(p => ({
+ id: `e-${p.id}`,
+ source: `${p.parent}`,
+ target: `${p.child}`,
+ label: p.length ? `${p.name} (${p.length},)` : `${p.name}`,
+ type: 'default',
+ animated: false,
+ style: {
+ 'stroke-width': p.length ? '3px' : '1px',
+ }
+ }))), []);
+
+ const [nodes, setNodes] = useState(null);
+ const [edges, setEdges] = useState(parameterEdges);
+
+ const onNodesChange = useCallback(
+ (changes) => setNodes((nds) => applyNodeChanges(changes, nds)),
+ [setNodes]
+ );
+ const onEdgesChange = useCallback(
+ (changes) => setEdges((eds) => applyEdgeChanges(changes, eds)),
+ [setEdges]
+ );
+
+ useEffect(() => {
+ const graph = {
+ id: "root",
+ layoutOptions: {
+ 'elk.algorithm': 'layered',
+ 'elk.nodePlacement.strategy': 'NETWORK_SIMPLEX',
+ 'elk.direction': 'DOWN',
+ 'elk.spacing.nodeNode': 20,
+ 'elk.layered.spacing.nodeNodeBetweenLayers': 90,
+ 'elk.aspectRatio': 1.0,
+ },
+ children: logLikelihoodNodes.map(n => (
+ { id: n.id, width: n.style.width, height: n.style.height}
+ )),
+ edges: parameterEdges.map(e => (
+ { id: e.id, sources: [e.source], targets: [e.target] }
+ )),
+ }
+
+ elk.layout(graph).then(graph => {
+ const newNodes = logLikelihoodNodes.map((n, i) => {
+ n.position.x = graph.children[i].x
+ n.position.y = graph.children[i].y
+ return n;
+ })
+ setNodes(newNodes)
+ setEdges(parameterEdges)
+ })
+
+ }, [JSON.stringify(inference.metadata)]);
+
+ const logLikelihoodsNoNull = inference.log_likelihoods.map(ll =>
+ Object.keys(ll).reduce((sum, key) => {
+ sum[key] = ll[key] || ""
+ return sum
+ }, {}))
+ const { control, handleSubmit, watch, setValue } = useForm({
+ defaultValues: {
+ ...inference,
+ initialization_inference: inference.initialization_inference || "",
+ log_likelihoods: logLikelihoodsNoNull
+ },
+ });
+
+ const datasets = useSelector(selectAllDatasets);
+ const dataset_options = datasets.map((dataset) => ({
+ key: dataset.name,
+ value: dataset.id,
+ })).concat([
+ { key: 'Use simulated data', value: '' }
+ ]);
+
+ const inferences = useSelector(selectAllInferences);
+ const inference_options = inferences.map((inference) => ({
+ key: inference.name,
+ value: inference.id,
+ })).concat([
+ { key: "None", value: "" }
+ ]);
+
+ const {
+ fields: logLikelihoods,
+ append: logLikelihoodsAppend,
+ remove: logLikelihoodsRemove,
+ } = useFieldArray({
+ control,
+ name: "log_likelihoods",
+ });
+
+
+ const handleDelete = () => {
+ dispatch(deleteInference(inference.id));
+ history.push(`/${project.id}/inference`);
+ };
+
+
+ const handleStop= () => {
+ dispatch(stopInference(inference.id));
+ };
+
+ const handleNewLoglikelihood = () =>
+ logLikelihoodsAppend({
+ form: "N",
+ variable: "",
+ priors: [],
+ parameters: [],
+ biomarker_type: "",
+ });
+
+ const max_number_of_iterations = watch(
+ "max_number_of_iterations",
+ inference.max_number_of_iterations
+ )
+
+
+ const onSubmit = (values) => {
+ values.log_likelihoods = values.log_likelihoods.map(ll =>
+ Object.keys(ll).reduce((sum, key) => {
+ let value = ll[key]
+ if (value === '') {
+ value = null
+ }
+ sum[key] = value
+ return sum
+ }, {})
+ )
+ dispatch(updateInference(values));
+ };
+
+ const readOnly = useSelector(state => userHasReadOnlyAccess(state, project)) || inference.read_only;
+
+ const algorithms = useSelector(selectAllAlgorithms);
+ const algorithm_options = algorithms
+ ? algorithms.map((algorithm) => ({
+ key: algorithm.name,
+ value: algorithm.id,
+ group: algorithm.category === "SA" ? "Sampling" : "Optimisation",
+ }))
+ : [{ key: "Loading...", value: null, group: null }];
+
+ const initialization_options = [
+ { key: "NA", value: "" },
+ { key: "Random from prior", value: "R" },
+ { key: "Default values of model", value: "D" },
+ { key: "From another inference", value: "F" },
+ ]
+
+
+
+ return (
+
+ );
+}
diff --git a/frontend/src/features/inference/InferenceDialog.js b/frontend/src/features/inference/InferenceDialog.js
new file mode 100644
index 00000000..0e4c98df
--- /dev/null
+++ b/frontend/src/features/inference/InferenceDialog.js
@@ -0,0 +1,784 @@
+import React, { useEffect, useState, useMemo } from "react";
+import { useSelector, useDispatch } from "react-redux";
+import { useForm, useFieldArray } from "react-hook-form";
+import Dialog from '@mui/material/Dialog';
+import DialogActions from '@mui/material/DialogActions';
+import makeStyles from '@mui/styles/makeStyles';
+import DialogContent from '@mui/material/DialogContent';
+import Container from "@mui/material/Container";
+import DialogContentText from '@mui/material/DialogContentText';
+import DialogTitle from '@mui/material//DialogTitle';
+import Button from '@mui/material/Button';
+import Popover from '@mui/material/Popover';
+import Alert from '@mui/material/Alert';
+import AlertTitle from '@mui/material/AlertTitle';
+import List from "@mui/material/List";
+import IconButton from "@mui/material/IconButton";
+import Tooltip from "@mui/material/Tooltip";
+import AddIcon from "@mui/icons-material/Add";
+import HelpIcon from "@mui/icons-material/Help";
+import DeleteIcon from "@mui/icons-material/Delete";
+import ListItem from "@mui/material/ListItem";
+import Grid from "@mui/material/Grid";
+import Stepper from '@mui/material/Stepper';
+import Step from '@mui/material/Step';
+import StepLabel from '@mui/material/StepLabel';
+import Typography from '@mui/material/Typography';
+import Divider from '@mui/material/Divider';
+import Paper from '@mui/material/Paper';
+
+import ModellingChart from '../modelling/Chart';
+import { FormTextField, FormSelectField, FormSliderField } from "../forms/FormComponents";
+import { selectAllAlgorithms } from "../inference/algorithmsSlice";
+import { selectAllDatasets } from "../datasets/datasetsSlice";
+import { runInferenceWizard, selectAllInferences } from "../inference/inferenceSlice";
+import { selectWritablePkModels, selectReadOnlyPkModels } from "../pkModels/pkModelsSlice";
+import { selectWritablePdModels, selectReadOnlyPdModels } from "../pdModels/pdModelsSlice";
+import {
+ selectBiomarkerTypesByDatasetId,
+ selectBiomarkerTypeById,
+} from "../datasets/biomarkerTypesSlice";
+import {
+ selectVariablesByPdModel,
+ selectVariablesByDosedPkModel,
+ selectVariableById,
+} from "../variables/variablesSlice";
+
+
+function variableGetDefaultValue(variable) {
+ if (variable.is_log) {
+ return Math.exp(variable.default_value)
+ } else {
+ return variable.default_value
+ }
+}
+
+const useStyles = makeStyles(() => ({
+ dialogPaper: {
+ minHeight: '500px',
+ maxHeight: '80vh',
+ },
+ listPaper: {
+ display: 'flex',
+ width: "100%",
+ },
+ chart: {
+ height: "50vh",
+ width: "100%",
+ },
+}));
+
+function HelpPopover() {
+ const [anchorEl, setAnchorEl] = React.useState(null);
+
+ const handleClick = (event) => {
+ setAnchorEl(event.currentTarget);
+ };
+
+ const handleClose = () => {
+ setAnchorEl(null);
+ };
+
+ const open = Boolean(anchorEl);
+ const id = open ? 'simple-popover' : undefined;
+
+ const helpText = 'Value can be a number (e.g. 1.0), or an expression in Python syntax ' +
+ '(e.g. 1.0 + parameter[central.clearence]^2). You can refer to other ' +
+ 'parameters using the syntax "parameter[]". You can ' +
+ 'refer to a biomarker in the chosen dataset using "biomarker[]"' +
+ '(e.g. 24.0 if biomarker[body weight] < 100 else 12.0). If there are more ' +
+ 'than one biomarker measurement for that subject / subject group then only the ' +
+ 'first measurement is used.';
+
+ return (
+
+
+
+
+
+
+ Help on defining parameter values
+ {helpText}
+
+
+
+
+ );
+}
+
+export default function InferenceDialog({ project, open, handleCloseDialog, defaultValues }) {
+ const dispatch = useDispatch();
+
+ const classes = useStyles();
+
+ const [activeStep, setActiveStep] = React.useState(0);
+
+ const steps = [
+ 'Model and dataset',
+ 'Observables',
+ 'Parameters',
+ 'Inference options',
+ ];
+
+ const handleNext = () => {
+ setActiveStep((prevActiveStep) => prevActiveStep + 1);
+ };
+
+ const handleBack = () => {
+ setActiveStep((prevActiveStep) => prevActiveStep - 1);
+ };
+
+ const algorithms = useSelector(selectAllAlgorithms);
+ const algorithm_options = algorithms
+ ? algorithms.map((algorithm) => ({
+ key: algorithm.name,
+ value: algorithm.id,
+ group: algorithm.category === "SA" ? "Sampling" : "Optimisation",
+ }))
+ : [{ key: "Loading...", value: null, group: null }];
+
+
+ const initialization_options = [
+ { key: "NA", value: "" },
+ { key: "Random from prior", value: "R" },
+ { key: "Default values of model", value: "D" },
+ { key: "From another inference", value: "F" },
+ ]
+
+ const pd_models = useSelector(state => selectWritablePdModels(state));
+ const dosed_pk_models = useSelector(state => selectWritablePkModels(state));
+ const model_options = pd_models.map((model) => ({
+ key: model.name,
+ value: JSON.stringify({id: model.id, form: 'PD'}),
+ group: 'Pharmacodynamic',
+ })).concat(dosed_pk_models.map((model) => ({
+ key: model.name,
+ value: JSON.stringify({id: model.id, form: 'PK'}),
+ group: 'Pharmacokinetic',
+ })));
+ const grouping_options = [
+ { key: 'by subject', value: 'subject' },
+ { key: 'by protocol', value: 'protocol' },
+ ]
+
+ if (defaultValues) {
+ defaultValues = {
+ ...defaultValues,
+ model: JSON.stringify(defaultValues.model),
+ }
+ } else if (!defaultValues) {
+ defaultValues = {
+ name: '',
+ grouping: 'protocol',
+ description: '',
+ project: project.id,
+ algorithm: 1,
+ initialization_strategy: 'R',
+ initialization_inference: '',
+ number_of_chains: 4,
+ max_number_of_iterations: 1000,
+ burn_in: 0,
+ model: '',
+ dataset: '',
+ }
+ }
+
+ const { control, handleSubmit, watch, setValue, reset } = useForm({
+ defaultValues
+ });
+
+ const handleClose= () => {
+ handleCloseDialog();
+ setActiveStep(0);
+ reset();
+ };
+
+ const {
+ fields: observations,
+ append: observationsAppend,
+ remove: observationsRemove,
+ replace: observationsReplace,
+ } = useFieldArray({
+ control,
+ name: "observations",
+ });
+
+ const {
+ fields: parameters,
+ replace: parametersReplace,
+ append: parametersAppend,
+ remove: parametersRemove,
+ } = useFieldArray({
+ control,
+ name: "parameters",
+ });
+
+ const modelId = watch("model")
+ const modelIdParse = modelId ? JSON.parse(modelId) : {id: null, form: null}
+ const datasetId = watch("dataset")
+
+ const chosenPkModel = dosed_pk_models.find(m => m.id === modelIdParse.id && modelIdParse.form === 'PK')
+ console.log('chosenPkModel', chosenPkModel)
+ console.log('defaultValues', defaultValues)
+ const chosenPdModel = pd_models.find(m => m.id === modelIdParse.id && modelIdParse.form === 'PD')
+
+ const variablesAll = useSelector((state) => {
+ if (modelId) {
+ if (modelIdParse.form === 'PD') {
+ return selectVariablesByPdModel(state, modelIdParse.id);
+ } else if (modelIdParse.form === 'PK') {
+ return selectVariablesByDosedPkModel(state, modelIdParse.id);
+ }
+ } else {
+ return [];
+ }
+ });
+ const variables = useMemo(
+ () => {
+ return variablesAll.filter(variable => variable.name !== "time")
+ },
+ [JSON.stringify(variablesAll)]
+ );
+
+ const biomarker_types = useSelector((state) =>
+ datasetId ? selectBiomarkerTypesByDatasetId(state, datasetId) : []
+ );
+ const biomarker_type_options = biomarker_types.map((biomarker_type) => ({
+ key: biomarker_type.name,
+ value: biomarker_type.name,
+ }));
+
+ const observedVariables = observations.map(obs => obs.model)
+ const variablesRemain = variables.filter(v => (
+ !v.constant && !observedVariables.includes(v.qname)
+ ))
+ const handleNewObservation = () => {
+ observationsAppend({
+ model: variablesRemain[0].qname,
+ biomarker: '',
+ noise_form: 'N',
+ noise_param_form: 'F',
+ parameters: [variableGetDefaultValue(variablesRemain[0])],
+ })
+ };
+ const handleDeleteObservation = (index) => () => {
+ observationsRemove(index)
+ };
+
+ useEffect(() => {
+ let model_observations = observations.filter(o => {
+ const variable = variables.find(v => v.qname === o.model)
+ if (variable) {
+ return true
+ }
+ return false
+ }).map( o => ({
+ ...o,
+ parameters: [...o.parameters]
+ }))
+ if (model_observations.length === 0 && variablesRemain.length > 0) {
+ model_observations = [
+ {
+ model: variablesRemain[0].qname,
+ biomarker: '',
+ noise_form: 'N',
+ noise_param_form: 'F',
+ parameters: [variableGetDefaultValue(variablesRemain[0])],
+ }
+ ]
+ }
+
+ const model_params = variables.filter(variable =>
+ variable.constant || variable.state
+ ).map(variable => {
+ const existing_param = parameters.find(p => p.name === variable.qname)
+ if (existing_param) {
+ return {
+ name: existing_param.name,
+ form: existing_param.form,
+ pooled: existing_param.pooled,
+ userDefined: existing_param.userDefined,
+ parameters: [...existing_param.parameters],
+ }
+ }
+ return {
+ name: variable.qname,
+ form: 'F',
+ pooled: true,
+ userDefined: false,
+ parameters: [variableGetDefaultValue(variable)],
+ }
+ })
+ parametersReplace(model_params)
+ observationsReplace(model_observations)
+ }
+ , [JSON.stringify(variables)]);
+
+ const handleNewParameter= () => {
+ parametersAppend({
+ name: 'New',
+ form: 'F',
+ pooled: true,
+ userDefined: true,
+ parameters: ['0.0'],
+ })
+ };
+ const handleDeleteParameter = (index) => () => {
+ parametersRemove(index)
+ };
+
+ const model_output_options = variables.filter(variable =>
+ !variable.constant
+ ).map(variable => ({
+ key: variable.qname, value: variable.qname
+ }))
+
+ const datasets = useSelector(selectAllDatasets);
+ const dataset_options = datasets.map((dataset) => ({
+ key: dataset.name,
+ value: dataset.id,
+ }));
+ const chosenDataset = datasets.find(d => d.id === datasetId)
+
+ const inferences = useSelector(selectAllInferences);
+ const inference_options = inferences.map((inference) => ({
+ key: inference.name,
+ value: inference.id,
+ })).concat([
+ { key: "None", value: "" }
+ ]);
+
+ const form_options = [
+ { key: "Normal", value: "N" },
+ { key: "LogNormal", value: "LN" },
+ { key: "Uniform", value: "U" },
+ { key: "Fixed", value: "F" },
+ ];
+
+ const obs_form_options = [
+ { key: "Normal", value: "N" },
+ { key: "LogNormal", value: "LN" },
+ ];
+
+ const handleFormChange = (baseName, variable, forObs) => (event) => {
+ const newForm = event.target.value;
+ if (variable) {
+ if (newForm === "F") {
+ const value = variableGetDefaultValue(variable)
+ setValue(`${baseName}.parameters[0]`, value);
+ } else if (newForm === "N" || newForm === 'LN') {
+ const mean = forObs ? 0 : variableGetDefaultValue(variable)
+ const standardDeviation = Math.sqrt(
+ Math.pow(variable.upper_bound - variable.lower_bound, 2) / 12
+ );
+ setValue(`${baseName}.parameters[0]`, mean);
+ setValue(`${baseName}.parameters[1]`, standardDeviation);
+ } else if (newForm === "U") {
+ const lower = variable.lower_bound
+ const upper = variable.upper_bound
+ setValue(`${baseName}.parameters[0]`, lower);
+ setValue(`${baseName}.parameters[1]`, upper);
+ }
+ }
+ };
+
+ const onSubmit = (values) => {
+ values = Object.keys(values).reduce((sum, key) => {
+ let value = values[key]
+ if (value === '') {
+ value = null
+ }
+ if (key === 'model') {
+ value = JSON.parse(value)
+ }
+ sum[key] = value
+ return sum
+ }, {})
+ dispatch(runInferenceWizard(values));
+ handleClose()
+ };
+
+ const max_number_of_iterations = watch(
+ "max_number_of_iterations"
+ )
+
+ const pooled_options = [
+ { value: true, key: 'Yes'},
+ { value: false, key: 'No'},
+ ]
+
+
+ const prior_parameter_render = (baseName, watchForm, showPooled) => {
+ const pooled = (
+
+
+ )
+ if (watchForm === 'F') {
+ return (
+
+ {showPooled && pooled}
+
+
+
+ )
+ } else if ((watchForm === 'N' || watchForm === 'LN')) {
+ return (
+
+ {showPooled && pooled}
+
+
+
+
+
+ )
+ } else if (watchForm === 'U') {
+ return (
+
+ {showPooled && pooled}
+
+
+
+
+
+ )
+ }
+ };
+
+ const stepRenders = [
+ (
+
+
+
+
+
+
+ {chosenPkModel && chosenDataset &&
+
+
+ Note: there are {chosenDataset.protocols.length} dosing protocols
+ and {chosenDataset.subjects.length} subjects in this dataset. The
+ inference will use generate one model per protocol
+
+
+ }
+
+
+
+ ),
+ (
+
+ {observations.map((obs, index) => {
+ const baseName = `observations[${index}]`
+ const watchForm = watch(`observations[${index}].noise_param_form`)
+ const variable = variables.find(v => v.qname === obs.model)
+ return (
+
+
+
+
+
+
+
+
+
+
+
+ {prior_parameter_render(baseName, watchForm, false)}
+
+
+
+
+
+ )
+ })}
+
+
+
+ ),
+ (
+
+ {parameters.map((param, index) => {
+ const baseName = `parameters[${index}]`
+ const watchForm = watch(`parameters[${index}].form`)
+ const variable = variables.find(v => v.qname === param.name)
+ return (
+
+
+
+
+ {prior_parameter_render(baseName, watchForm, true)}
+
+
+
+
+ )
+ })}
+
+
+
+
+ ),
+ (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ),
+
+ ]
+
+ return (
+
+
+
+ )
+}
diff --git a/frontend/src/features/inference/InferenceListDialog.js b/frontend/src/features/inference/InferenceListDialog.js
new file mode 100644
index 00000000..b8e598d3
--- /dev/null
+++ b/frontend/src/features/inference/InferenceListDialog.js
@@ -0,0 +1,142 @@
+import React, { useEffect } from "react";
+import { useDispatch, useSelector } from "react-redux";
+import Button from "@mui/material/Button";
+import Dialog from '@mui/material/Dialog';
+import DialogContent from '@mui/material/DialogContent';
+import makeStyles from '@mui/styles/makeStyles';
+import { selectAllInferences } from "../inference/inferenceSlice";
+import Table from '@mui/material/Table';
+import TableCell from '@mui/material/TableCell';
+import Tooltip from "@mui/material/Tooltip";
+import TableContainer from '@mui/material/TableContainer';
+import TableBody from '@mui/material/TableBody';
+import TableRow from '@mui/material/TableRow';
+import TableHead from '@mui/material/TableHead';
+
+import Typography from "@mui/material/Typography";
+import DialogActions from "@mui/material/DialogActions";
+
+import LinearProgressWithLabel from '../menu/LinearProgressWithLabel'
+
+const useStyles = makeStyles((theme) => ({
+ container: {
+ },
+ paper: {
+ padding: theme.spacing(2),
+ textAlign: "left",
+ },
+ controlsRoot: {
+ display: "flex",
+ alignItems: "center",
+ },
+ controls: {
+ margin: theme.spacing(1),
+ },
+}));
+
+
+
+export default function InferenceListDialog({ project, onClose, model_type, model, open }) {
+ const classes = useStyles();
+ const [value, setValue] = React.useState(0);
+ const handleClose = () => {
+ onClose();
+ };
+
+ let items = useSelector(selectAllInferences);
+ const pd_models = useSelector(state => state.pdModels.entities);
+ const pk_models = useSelector(state => state.pkModels.entities);
+ const datasets = useSelector(state => state.datasets.entities);
+ // fetch model and dataset name
+ if (items) {
+ items = items.map(item => {
+ const model_id = item.metadata.model.id;
+ const dataset_id = item.metadata.dataset;
+ const dataset = datasets[dataset_id];
+ const model_type = item.metadata.model.form;
+ let model = null
+ if (model_type === 'PK') {
+ model = pk_models[model_id]
+ }
+ if (model_type === 'PD') {
+ model = pd_models[model_id]
+ }
+ console.log(item, model, dataset)
+ return {...item, model, dataset}
+ })
+ }
+
+ const handleRowClick = (item) => {
+ onClose(item);
+ }
+
+ const column_headings = [
+ {label: 'Name', help: 'Name'},
+ {label: 'Description', help: 'Description'},
+ {label: 'Model', help: 'Model'},
+ {label: 'Dataset', help: 'Dataset'},
+ {label: 'Progress', help: 'Progress'},
+ ]
+
+ console.log('inference', items)
+
+ return (
+
+
+
+ Choose an inference
+
+
+
+
+
+ {column_headings.map(heading => (
+
+
+
+ {heading.label}
+
+
+
+
+ ))
+ }
+
+
+
+ {items.map((item) => {
+ const progress =
+ (100 * item.number_of_iterations) /
+ item.max_number_of_iterations;
+ return (
+
+ handleRowClick(item)}>
+
+ {item.name}
+
+
+ {item.description}
+
+
+ {item.model?.name}
+
+
+ {item.dataset.name}
+
+
+
+
+
+ )
+ })}
+
+
+
+
+
+ Close
+
+
+ );
+}
diff --git a/frontend/src/features/inference/Inferences.js b/frontend/src/features/inference/Inferences.js
new file mode 100644
index 00000000..447f4e6f
--- /dev/null
+++ b/frontend/src/features/inference/Inferences.js
@@ -0,0 +1,154 @@
+import React, { useEffect } from "react";
+import { useSelector } from "react-redux";
+import Paper from "@mui/material/Paper";
+import Grid from "@mui/material/Grid";
+import Table from '@mui/material/Table';
+import { useHistory, useParams } from "react-router-dom";
+import Typography from '@mui/material/Typography';
+import Container from '@mui/material/Container';
+import LinearProgress from "@mui/material/LinearProgress";
+import TableBody from '@mui/material/TableBody';
+import ProjectDetail from "../projects/ProjectDetail";
+import Tooltip from "@mui/material/Tooltip";
+import { useTheme } from "@mui/material/styles";
+import Box from "@mui/material/Box";
+import { useDispatch } from "react-redux";
+import TableCell from '@mui/material/TableCell';
+import SaveIcon from '@mui/icons-material/Save';
+import TableContainer from '@mui/material/TableContainer';
+import TableHead from '@mui/material/TableHead';
+import DeleteIcon from '@mui/icons-material/Delete';
+import TableRow from '@mui/material/TableRow';
+
+import AddIcon from "@mui/icons-material/Add";
+
+import IconButton from "@mui/material/IconButton";
+import makeStyles from '@mui/styles/makeStyles';
+
+import LinearProgressWithLabel from '../menu/LinearProgressWithLabel'
+import InferenceDialog from './InferenceDialog'
+
+import {
+ addNewInference,
+ selectAllInferences,
+ deleteInference,
+} from "./inferenceSlice.js";
+
+const useStyles = makeStyles((theme) => ({
+ container: {
+ },
+ paper: {
+ padding: theme.spacing(2),
+ textAlign: "left",
+ },
+ controlsRoot: {
+ display: "flex",
+ alignItems: "center",
+ },
+ controls: {
+ margin: theme.spacing(1),
+ },
+}));
+
+
+
+export default function Inferences({ project }) {
+ const classes = useStyles();
+ const theme = useTheme();
+ const dispatch = useDispatch();
+ const history = useHistory();
+
+ const [openDialog, setOpenDialog] = React.useState(false);
+ const handleCloseDialog = () => {
+ setOpenDialog(false);
+ };
+
+ const handleNewRow = () => {
+ setOpenDialog(true);
+ };
+ const items = useSelector(selectAllInferences);
+
+ const handleRowClick = (item) => {
+ history.push(`/${project.id}/inference/${item.id}/`);
+ }
+
+ const handleDelete = (id) => (event) => {
+ event.stopPropagation()
+ dispatch(deleteInference(id));
+ }
+
+ const column_headings = [
+ {label: 'Name', help: 'Name'},
+ {label: 'Description', help: 'Description'},
+ {label: 'Progress', help: 'Progress'},
+ {label: 'Actions', help: 'Click icon to perform actions'},
+ ]
+
+ return (
+
+
+ My Inferences
+
+
+
+
+
+ {column_headings.map(heading => (
+
+
+
+ {heading.label}
+
+
+
+
+ ))
+ }
+
+
+
+ {items.map((item) => {
+ const progress =
+ (100 * item.number_of_iterations) /
+ item.max_number_of_iterations;
+ return (
+
+ handleRowClick(item)}>
+
+ {item.name}
+
+
+ {item.description}
+
+
+
+
+
+
+
+
+
+
+
+
+ );
+ })}
+
+
+
+
+
+
+
+
+ );
+}
+
diff --git a/frontend/src/features/inference/algorithmsSlice.js b/frontend/src/features/inference/algorithmsSlice.js
new file mode 100644
index 00000000..85487f51
--- /dev/null
+++ b/frontend/src/features/inference/algorithmsSlice.js
@@ -0,0 +1,76 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+
+const algorithmsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = algorithmsAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchAlgorithms = createAsyncThunk(
+ "algorithms/fetchAlgorithms",
+ async (project, { getState }) => {
+ const response = await api.get(`/api/algorithm/`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const addNewAlgorithm = createAsyncThunk(
+ "algorithms/addNewAlgorithm",
+ async (_, { getState }) => {
+ const initialAlgorithm = {
+ name: "new",
+ };
+ const algorithm = await api.post("/api/algorithm/", getState().login.csrf, initialAlgorithm);
+ return algorithm;
+ }
+);
+
+export const updateAlgorithm = createAsyncThunk(
+ "algorithms/updateAlgorithm",
+ async (algorithm, {getState}) => {
+ const response = await api.put(
+ `/api/algorithm/${algorithm.id}/`, getState().login.csrf,
+ algorithm
+ );
+ return response;
+ }
+);
+
+export const algorithmsSlice = createSlice({
+ name: "algorithms",
+ initialState,
+ reducers: {},
+ extraReducers: {
+ [fetchAlgorithms.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchAlgorithms.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchAlgorithms.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ algorithmsAdapter.setAll(state, action.payload);
+ },
+ [addNewAlgorithm.fulfilled]: algorithmsAdapter.addOne,
+ [updateAlgorithm.fulfilled]: algorithmsAdapter.upsertOne,
+ },
+});
+
+// export const {} = algorithmsSlice.actions
+
+export default algorithmsSlice.reducer;
+
+export const {
+ selectAll: selectAllAlgorithms,
+ selectById: selectAlgorithmById,
+ selectIds: selectAlgorithmIds,
+} = algorithmsAdapter.getSelectors((state) => state.algorithms);
diff --git a/frontend/src/features/inference/chainSlice.js b/frontend/src/features/inference/chainSlice.js
new file mode 100644
index 00000000..3d09247b
--- /dev/null
+++ b/frontend/src/features/inference/chainSlice.js
@@ -0,0 +1,93 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+
+const chainsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = chainsAdapter.getInitialState({
+ status: "idle",
+ errorFetch: null,
+});
+
+export const fetchChains = createAsyncThunk(
+ "chains/fetchChains",
+ async (project, { dispatch }) => {
+ let response = await api.get(
+ `/api/inference_chain/?project_id=${project.id}`
+ );
+ return response;
+ }
+);
+
+export const fetchChainById = createAsyncThunk(
+ "chains/fetchChainById",
+ async (model_id, { dispatch }) => {
+ let response = await api.get(`/api/inference_chain/${model_id}/`);
+ return response;
+ }
+);
+
+export const fetchChainsByInferenceId = createAsyncThunk(
+ "chains/fetchChainByInference",
+ async (inferenceId, { dispatch, getState }) => {
+ let response = await api.get(
+ `/api/inference_chain/?inference_id=${inferenceId}`
+ );
+
+ const state = getState()
+ const responseIds = response.map(chain => chain.id)
+ const existingChains = selectChainsByInferenceId(state, inferenceId)
+ const deletedChains = existingChains.filter(chain => responseIds.indexOf(chain.id) == -1)
+ return {
+ chains: response,
+ deletedChains
+ };
+ }
+);
+
+export const chainsSlice = createSlice({
+ name: "chains",
+ initialState,
+ reducers: {
+ },
+ extraReducers: {
+ [fetchChains.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchChains.rejected]: (state, action) => {
+ state.status = "failed";
+ state.errorFetch = action.error.message;
+ },
+ [fetchChains.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ chainsAdapter.setAll(state, action.payload);
+ },
+ [fetchChainsByInferenceId.fulfilled]: (state, action) => {
+ if (action.payload.deletedChains.length > 0) {
+ chainsAdapter.removeMany(state, action.payload.deletedChains.map(c => c.id))
+ }
+ chainsAdapter.upsertMany(state, action.payload.chains)
+ },
+ [fetchChainById.fulfilled]: chainsAdapter.upsertOne,
+ },
+});
+
+export const { toggleChain } = chainsSlice.actions;
+
+export default chainsSlice.reducer;
+
+export const {
+ selectAll: selectAllChains,
+ selectById: selectChainById,
+ selectIds: selectChainIds,
+} = chainsAdapter.getSelectors((state) => state.chains);
+
+
+export const selectChainsByInferenceId = (state, id) => {
+ return selectAllChains(state).filter((chain) => chain.inference === id);
+};
diff --git a/frontend/src/features/inference/inferenceSlice.js b/frontend/src/features/inference/inferenceSlice.js
new file mode 100644
index 00000000..37405aa9
--- /dev/null
+++ b/frontend/src/features/inference/inferenceSlice.js
@@ -0,0 +1,216 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+import { normalize, schema } from "normalizr";
+import { fetchPdModelById} from '../pdModels/pdModelsSlice'
+import { fetchPkModelById} from '../pkModels/pkModelsSlice'
+import {
+ fetchVariablesByPkModel,
+ fetchVariablesByPdModel
+} from '../variables/variablesSlice'
+
+const inferencesAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = inferencesAdapter.getInitialState({
+ status: "idle",
+ errorFetch: null,
+ selectedId: null,
+});
+
+const variable = new schema.Entity("variables");
+const pd_model = new schema.Entity("pd_models");
+const dosed_pk_model = new schema.Entity("dosed_pk_models");
+const inference = new schema.Entity("inferences", {
+ variables: [variable],
+ pd_model_detail: pd_model,
+ dosed_pk_model_detail: dosed_pk_model,
+});
+
+export const fetchInferences = createAsyncThunk(
+ "inferences/fetchInferences",
+ async (project_id, { dispatch, getState }) => {
+ let response = await api.get(`/api/inference/?project_id=${project_id}`, getState().login.csrf);
+ //const normalized = normalize(response, [inference]);
+ //console.log("fetchInferences got", response, normalized);
+
+ return response;
+ }
+);
+
+export const fetchInferenceById = createAsyncThunk(
+ "inferences/fetchInferenceById",
+ async (inferenceId, { dispatch, getState }) => {
+ let inference = await api.get(`/api/inference/${inferenceId}/`, getState().login.csrf);
+ return inference;
+ }
+);
+
+export const addNewInference = createAsyncThunk(
+ "inferences/addNewInference",
+ async (project, { dispatch, getState }) => {
+ const initialInference = {
+ name: "new",
+ project: project.id,
+ log_likelihoods: [],
+ };
+ let inference = await api.post("/api/inference/", getState().login.csrf, initialInference);
+ inference.chosen = true;
+
+ return inference;
+ }
+);
+
+export const updateInference = createAsyncThunk(
+ "inferences/updateInference",
+ async (inference, { dispatch, getState }) => {
+ const response = await api.put(
+ `/api/inference/${inference.id}/`, getState().login.csrf,
+ inference
+ );
+ return response;
+ }
+);
+
+export const runInferenceWizard = createAsyncThunk(
+ "inferences/runInferenceWizard",
+ async (inference, { dispatch, getState }) => {
+ const newInference = await api.post(`/api/inference/wizard`, getState().login.csrf, inference);
+ for (const log_likelihood of newInference.log_likelihoods) {
+ if (log_likelihood.model && log_likelihood.model[0] === 'pkpdapp_pharmacodynamicmodel') {
+ dispatch(fetchPdModelById(log_likelihood.model[1]))
+ dispatch(fetchVariablesByPdModel(log_likelihood.model[1]))
+ }
+ if (log_likelihood.model && log_likelihood.model[0] === 'pkpdapp_dosedpharmacokineticmodel') {
+ dispatch(fetchPkModelById(log_likelihood.model[1]))
+ dispatch(fetchVariablesByPkModel(log_likelihood.model[1]))
+ }
+ }
+ return {
+ newInference,
+ inference,
+ }
+ }
+);
+
+export const runInference = createAsyncThunk(
+ "inferences/runInference",
+ async (inferenceId, { dispatch, getState }) => {
+ const newInference = await api.post(`/api/inference/${inferenceId}/run`, getState().login.csrf);
+ //const normalized = normalize(newInference, inference);
+ for (const log_likelihood of newInference.log_likelihoods) {
+ if (log_likelihood.pd_model) {
+ dispatch(fetchPdModelById(log_likelihood.pd_model))
+ dispatch(fetchVariablesByPdModel(log_likelihood.pd_model))
+ }
+ if (log_likelihood.dosed_pk_model){
+ dispatch(fetchPkModelById(log_likelihood.dosed_pk_model))
+ dispatch(fetchVariablesByPkModel(log_likelihood.dosed_pk_model))
+ }
+ }
+ return newInference;
+ }
+);
+
+export const stopInference = createAsyncThunk(
+ "inferences/stopInference",
+ async (inferenceId, { dispatch, getState }) => {
+ const newInference = await api.post(`/api/inference/${inferenceId}/stop`, getState().login.csrf);
+ //const normalized = normalize(newInference, inference);
+ return newInference;
+ }
+);
+
+export const deleteInference = createAsyncThunk(
+ "inferences/deleteInference",
+ async (inferenceId, { dispatch, getState }) => {
+ await api.delete(`/api/inference/${inferenceId}/`, getState().login.csrf);
+ return inferenceId;
+ }
+);
+
+export const inferencesSlice = createSlice({
+ name: "inferences",
+ initialState,
+ reducers: {
+ toggleInference(state, action) {
+ for (let inference of Object.values(state.entities)) {
+ if (inference.id === action.payload.id) {
+ inference.chosen = true
+ } else {
+ inference.chosen = false
+ }
+ }
+ },
+ setInferenceError(state, action) {
+ let inference = state.entities[action.payload.id];
+ inference.error = action.payload.error;
+ },
+ },
+ extraReducers: {
+ [fetchInferences.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchInferences.rejected]: (state, action) => {
+ state.status = "failed";
+ state.errorFetch = action.error.message;
+ },
+ [fetchInferences.fulfilled]: (state, action) => {
+ inferencesAdapter.upsertMany(state, action.payload);
+ state.status = "succeeded";
+ },
+ [fetchInferenceById.fulfilled]: inferencesAdapter.upsertOne,
+ [runInference.fulfilled]: (state, action) => {
+ inferencesAdapter.upsertOne(state, action.payload);
+ },
+ [runInferenceWizard.fulfilled]: (state, action) => {
+ if (action.payload.inference.id) {
+ inferencesAdapter.removeOne(state, action.payload.inference.id);
+ }
+ for (let inference of Object.values(state.entities)) {
+ inference.chosen = false
+ }
+ action.payload.newInference.chosen = true
+ inferencesAdapter.upsertOne(state, action.payload.newInference);
+ },
+ [stopInference.fulfilled]: (state, action) => {
+ inferencesAdapter.upsertOne(state, action.payload);
+ },
+ [addNewInference.fulfilled]: inferencesAdapter.addOne,
+ [updateInference.fulfilled]: inferencesAdapter.upsertOne,
+ [deleteInference.fulfilled]: inferencesAdapter.removeOne,
+ },
+});
+
+export const { toggleInference } = inferencesSlice.actions;
+
+export default inferencesSlice.reducer;
+
+export const {
+ selectAll: selectAllInferences,
+ selectById: selectInferenceById,
+ selectIds: selectInferenceIds,
+} = inferencesAdapter.getSelectors((state) => state.inferences);
+
+export const selectChosenInferences = (state) =>
+ selectAllInferences(state).filter((inference) => inference.chosen);
+
+export const selectChosenRunningInferences = (state) =>
+ selectAllInferences(state).filter(
+ (inference) => inference.chosen && inference.read_only
+ );
+
+export const selectChosenDraftInferences = (state) =>
+ selectAllInferences(state).filter(
+ (inference) => inference.chosen && !inference.read_only
+ );
+
+export const selectAllDraftInferences = (state) =>
+ selectAllInferences(state).filter((inference) => !inference.read_only);
+
+export const selectAllRunningInferences = (state) =>
+ selectAllInferences(state).filter((inference) => inference.read_only);
diff --git a/frontend/src/features/inference/objectiveFunctionsSlice.js b/frontend/src/features/inference/objectiveFunctionsSlice.js
new file mode 100644
index 00000000..985d291b
--- /dev/null
+++ b/frontend/src/features/inference/objectiveFunctionsSlice.js
@@ -0,0 +1,99 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+
+const objectiveFunctionsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = objectiveFunctionsAdapter.getInitialState({
+ status: "idle",
+ errorFetch: null,
+});
+
+export const fetchObjectiveFunctionsByInference = createAsyncThunk(
+ "objectiveFunctions/fetchObjectiveFunctions",
+ async (inference, { dispatch }) => {
+ let response = await api.get(
+ `/api/objective_function/?inference_id=${inference.id}`
+ );
+ return response;
+ }
+);
+
+export const fetchObjectiveFunctionById = createAsyncThunk(
+ "objectiveFunctions/fetchObjectiveFunctionById",
+ async (objectiveFunctionId, { dispatch }) => {
+ let objectiveFunction = await api.get(
+ `/api/objective_function/${objectiveFunctionId}/`
+ );
+ return objectiveFunction;
+ }
+);
+
+export const addNewObjectiveFunction = createAsyncThunk(
+ "objectiveFunctions/addNewObjectiveFunction",
+ async (project, { dispatch }) => {
+ const initialObjectiveFunction = {
+ name: "new",
+ project: project.id,
+ };
+ let objectiveFunction = await api.post(
+ "/api/objective_function/",
+ initialObjectiveFunction
+ );
+
+ return objectiveFunction;
+ }
+);
+
+export const updateObjectiveFunction = createAsyncThunk(
+ "objectiveFunctions/updateObjectiveFunction",
+ async (objectiveFunction, { getState }) => {
+ const response = await api.put(
+ `/api/objective_function/${objectiveFunction.id}/`,
+ objectiveFunction
+ );
+ return response;
+ }
+);
+
+export const deleteObjectiveFunction = createAsyncThunk(
+ "objectiveFunctions/deleteObjectiveFunction",
+ async (objectiveFunctionId, { dispatch }) => {
+ await api.delete(`/api/objective_function/${objectiveFunctionId}`);
+ return objectiveFunctionId;
+ }
+);
+
+export const objectiveFunctionsSlice = createSlice({
+ name: "objectiveFunctions",
+ initialState,
+ reducers: {},
+ extraReducers: {
+ [fetchObjectiveFunctionById.fulfilled]: objectiveFunctionsAdapter.upsertOne,
+ [fetchObjectiveFunctionsByInference.fulfilled]:
+ objectiveFunctionsAdapter.upsertMany,
+ [addNewObjectiveFunction.fulfilled]: objectiveFunctionsAdapter.addOne,
+ [updateObjectiveFunction.fulfilled]: objectiveFunctionsAdapter.upsertOne,
+ [deleteObjectiveFunction.fulfilled]: objectiveFunctionsAdapter.removeOne,
+ },
+});
+
+export const { toggleObjectiveFunction } = objectiveFunctionsSlice.actions;
+
+export default objectiveFunctionsSlice.reducer;
+
+export const {
+ selectAll: selectAllObjectiveFunctions,
+ selectById: selectObjectiveFunctionById,
+ selectIds: selectObjectiveFunctionIds,
+} = objectiveFunctionsAdapter.getSelectors((state) => state.objectiveFunctions);
+
+export const selectObjectiveFunctionsByInference = (state, inference) =>
+ selectAllObjectiveFunctions(state).filter(
+ (objectiveFunction) => objectiveFunction.inference === inference.id
+ );
diff --git a/frontend/src/features/inference/priorsSlice.js b/frontend/src/features/inference/priorsSlice.js
new file mode 100644
index 00000000..707fd8c1
--- /dev/null
+++ b/frontend/src/features/inference/priorsSlice.js
@@ -0,0 +1,86 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+
+const priorsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = priorsAdapter.getInitialState({
+ status: "idle",
+ errorFetch: null,
+});
+
+export const fetchPriorsByInference = createAsyncThunk(
+ "priors/fetchPriors",
+ async (inference, { dispatch }) => {
+ let response = await api.get(`/api/prior/?inference_id=${inference.id}`);
+ return response;
+ }
+);
+
+export const fetchPriorById = createAsyncThunk(
+ "priors/fetchPriorById",
+ async (priorId, { dispatch }) => {
+ let prior = await api.get(`/api/prior/${priorId}/`);
+ return prior;
+ }
+);
+
+export const addNewPrior = createAsyncThunk(
+ "priors/addNewPrior",
+ async (project, { dispatch }) => {
+ const initialPrior = {
+ name: "new",
+ project: project.id,
+ };
+ let prior = await api.post("/api/prior/", initialPrior);
+
+ return prior;
+ }
+);
+
+export const updatePrior = createAsyncThunk(
+ "priors/updatePrior",
+ async (prior, { getState }) => {
+ const response = await api.put(`/api/prior/${prior.id}/`, prior);
+ return response;
+ }
+);
+
+export const deletePrior = createAsyncThunk(
+ "priors/deletePrior",
+ async (priorId, { dispatch }) => {
+ await api.delete(`/api/prior/${priorId}`);
+ return priorId;
+ }
+);
+
+export const priorsSlice = createSlice({
+ name: "priors",
+ initialState,
+ reducers: {},
+ extraReducers: {
+ [fetchPriorById.fulfilled]: priorsAdapter.upsertOne,
+ [fetchPriorsByInference.fulfilled]: priorsAdapter.upsertMany,
+ [addNewPrior.fulfilled]: priorsAdapter.addOne,
+ [updatePrior.fulfilled]: priorsAdapter.upsertOne,
+ [deletePrior.fulfilled]: priorsAdapter.removeOne,
+ },
+});
+
+export const { togglePrior } = priorsSlice.actions;
+
+export default priorsSlice.reducer;
+
+export const {
+ selectAll: selectAllPriors,
+ selectById: selectPriorById,
+ selectIds: selectPriorIds,
+} = priorsAdapter.getSelectors((state) => state.priors);
+
+export const selectPriorsByInference = (state, inference) =>
+ selectAllPriors(state).filter((prior) => prior.inference === inference.id);
diff --git a/frontend/src/features/login/ActivateUser.js b/frontend/src/features/login/ActivateUser.js
new file mode 100644
index 00000000..58848581
--- /dev/null
+++ b/frontend/src/features/login/ActivateUser.js
@@ -0,0 +1,54 @@
+import makeStyles from '@mui/styles/makeStyles';
+import React, { useEffect } from "react";
+import { Link } from "react-router-dom";
+import Typography from "@mui/material/Typography";
+import { useHistory, useParams } from "react-router-dom";
+import Container from "@mui/material/Container";
+import { ReactComponent as PkpdAppIcon } from "../../logo_pkpdapp_with_text.svg";
+import { api } from "../../Api";
+
+const useStyles = makeStyles((theme) => ({
+ paper: {
+ marginTop: theme.spacing(8),
+ display: "flex",
+ flexDirection: "column",
+ alignItems: "center",
+ },
+ icon: {
+ margin: theme.spacing(3),
+ width: theme.spacing(20),
+ height: theme.spacing(8),
+ },
+ links: {
+ "& > *": {
+ margin: theme.spacing(1),
+ },
+ },
+}));
+
+export default function ActivateUser() {
+ const classes = useStyles();
+
+ let { uid, token } = useParams();
+ const history = useHistory();
+
+ useEffect(() => {
+ api.post("/auth/users/activation/", { uid, token }, false).then((data) => {
+ history.push("/activate-success");
+ });
+ });
+
+ return (
+
+
+
+
+ Activating User
+
+
+
+
+ );
+}
diff --git a/frontend/src/features/login/ActivateUserSuccess.js b/frontend/src/features/login/ActivateUserSuccess.js
new file mode 100644
index 00000000..b43513cb
--- /dev/null
+++ b/frontend/src/features/login/ActivateUserSuccess.js
@@ -0,0 +1,7 @@
+import React from "react";
+import Success from "./Success";
+
+export default function ActivateUserSuccess() {
+ const text = "You have successfully activated your account";
+ return
+
+ );
+}
diff --git a/frontend/src/features/login/Register.js b/frontend/src/features/login/Register.js
new file mode 100644
index 00000000..037baa5a
--- /dev/null
+++ b/frontend/src/features/login/Register.js
@@ -0,0 +1,128 @@
+import { api } from "../../Api";
+import makeStyles from '@mui/styles/makeStyles';
+import React from "react";
+import { Link } from "react-router-dom";
+import Button from "@mui/material/Button";
+import { useForm } from "react-hook-form";
+import Typography from "@mui/material/Typography";
+import Container from "@mui/material/Container";
+import { useHistory } from "react-router-dom";
+import { FormTextField } from "../forms/FormComponents";
+import { ReactComponent as PkpdAppIcon } from "../../logo_pkpdapp_with_text.svg";
+
+const useStyles = makeStyles((theme) => ({
+ paper: {
+ marginTop: theme.spacing(8),
+ display: "flex",
+ flexDirection: "column",
+ alignItems: "center",
+ },
+ icon: {
+ margin: theme.spacing(3),
+ width: theme.spacing(20),
+ height: theme.spacing(8),
+ },
+ form: {
+ width: "100%", // Fix IE 11 issue.
+ marginTop: theme.spacing(1),
+ },
+ submit: {
+ margin: theme.spacing(3, 1, 2),
+ },
+ links: {
+ "& > *": {
+ margin: theme.spacing(1),
+ },
+ },
+}));
+
+export default function Register() {
+ const classes = useStyles();
+ const { control, handleSubmit } = useForm();
+
+ const history = useHistory();
+
+ const onSubmit = (values) => {
+ api.post("/auth/users/", values, false).then((data) => {
+ history.push("/register-success");
+ });
+ };
+
+ return (
+
+
+
+
+ Register new user
+
+
+
+
+
+ );
+}
diff --git a/frontend/src/features/login/RegisterSuccess.js b/frontend/src/features/login/RegisterSuccess.js
new file mode 100644
index 00000000..2cfb3ede
--- /dev/null
+++ b/frontend/src/features/login/RegisterSuccess.js
@@ -0,0 +1,8 @@
+import React from "react";
+import Success from "./Success";
+
+export default function RegisterSuccess() {
+ const text =
+ "You have successfully created a new user, please check your email for a link to activate this account";
+ return
+
+
+
+ Register new user
+
+
+
+
+
+ );
+}
diff --git a/frontend/src/features/login/ResetPasswordRequest.js b/frontend/src/features/login/ResetPasswordRequest.js
new file mode 100644
index 00000000..29b95ba1
--- /dev/null
+++ b/frontend/src/features/login/ResetPasswordRequest.js
@@ -0,0 +1,83 @@
+import { api } from "../../Api";
+import makeStyles from '@mui/styles/makeStyles';
+import React from "react";
+import { Link } from "react-router-dom";
+import Button from "@mui/material/Button";
+import { useForm } from "react-hook-form";
+import Typography from "@mui/material/Typography";
+import Container from "@mui/material/Container";
+import { useHistory } from "react-router-dom";
+import { FormTextField } from "../forms/FormComponents";
+import { ReactComponent as PkpdAppIcon } from "../../logo_pkpdapp_with_text.svg";
+
+const useStyles = makeStyles((theme) => ({
+ paper: {
+ marginTop: theme.spacing(8),
+ display: "flex",
+ flexDirection: "column",
+ alignItems: "center",
+ },
+ icon: {
+ margin: theme.spacing(3),
+ width: theme.spacing(20),
+ height: theme.spacing(8),
+ },
+ form: {
+ width: "100%", // Fix IE 11 issue.
+ marginTop: theme.spacing(1),
+ },
+ submit: {
+ margin: theme.spacing(3, 1, 2),
+ },
+ links: {
+ "& > *": {
+ margin: theme.spacing(1),
+ },
+ },
+}));
+
+export default function ResetPasswordRequest() {
+ const classes = useStyles();
+ const { control, handleSubmit } = useForm();
+
+ const history = useHistory();
+
+ const onSubmit = (values) => {
+ api.post("/auth/users/reset_password/", values, false).then((data) => {
+ history.push("/reset-password-request-success");
+ });
+ };
+
+ return (
+
+
+
+
+ Password Reset Request
+
+
+
+
+
+ );
+}
diff --git a/frontend/src/features/login/ResetPasswordRequestSuccess.js b/frontend/src/features/login/ResetPasswordRequestSuccess.js
new file mode 100644
index 00000000..5fdc6f71
--- /dev/null
+++ b/frontend/src/features/login/ResetPasswordRequestSuccess.js
@@ -0,0 +1,8 @@
+import React from "react";
+import Success from "./Success";
+
+export default function ResetPasswordRequestSuccess() {
+ const text =
+ "Request submitted, please check your email for a link to complete the password reset";
+ return
+
+
+
+ Success
+
+
{text}
+
+
+
+ );
+}
diff --git a/frontend/src/features/login/loginSlice.js b/frontend/src/features/login/loginSlice.js
new file mode 100644
index 00000000..fa7447f2
--- /dev/null
+++ b/frontend/src/features/login/loginSlice.js
@@ -0,0 +1,136 @@
+import { createSlice, PayloadAction, createAsyncThunk } from "@reduxjs/toolkit";
+
+import { api } from "../../Api";
+
+
+export const fetchCsrf = createAsyncThunk(
+ "login/fetchCsrf",
+ async (project, { dispatch }) => {
+ const response = await fetch("/api/csrf/", {
+ method: "GET",
+ credentials: "include",
+ }).then(response => response.json());
+ localStorage.setItem("csrf", response['X-CSRFToken']);
+ return response['X-CSRFToken'];
+ }
+);
+
+export const fetchSession = createAsyncThunk(
+ "login/fetchSession",
+ async (_, { dispatch }) => {
+ const { isAuthenticated, user } = await fetch("/api/session/", {
+ method: "GET",
+ credentials: "include",
+ }).then((response) => {
+ dispatch(fetchCsrf());
+ return isResponseOk(response)
+ }).then(data =>
+ ({ isAuthenticated: true, user: data.user })
+ ).catch((err) =>
+ ({ isAuthenticated: false, user: null })
+ );
+ console.log('fetchSession', isAuthenticated, user)
+ return { isAuthenticated, user };
+ }
+);
+
+function isResponseOk(response) {
+ if (response.status >= 200 && response.status <= 299) {
+ return response.json();
+ } else {
+ throw Error(response.statusText);
+ }
+}
+
+
+
+export const login = createAsyncThunk(
+ "login/login",
+ async ({username, password}, { getState, dispatch }) => {
+ const csrf = getState().login.csrf;
+ const response = fetch("/api/login/", {
+ method: "POST",
+ credentials: "include",
+ headers: {
+ "Content-Type": "application/json",
+ "X-CSRFToken": csrf,
+ },
+ body: JSON.stringify({username: username, password: password}),
+ })
+ .then(isResponseOk)
+ .then((data) => {
+ //dispatch(fetchCsrf());
+ return {isAuthenticated: true, user: data.user, error: null}
+ })
+ .catch((err) => {
+ return {isAuthenticated: false, user: null, error: "Wrong usename or password"}
+ });
+ return response;
+ }
+);
+
+export const logout = createAsyncThunk(
+ "login/logout",
+ async (_, { dispatch }) => {
+ const response = await fetch("/api/logout/", {
+ method: "GET",
+ credentials: "include",
+ })
+ .then(isResponseOk)
+ .then((data) => {
+ dispatch(fetchCsrf());
+ return {isAuthenticated: false}
+ });
+ return response;
+ }
+);
+
+const slice = createSlice({
+
+ name: "login",
+ initialState: { user: null, csrf: null, isAuthenticated: false, error: null },
+ reducers: {
+ setCredentials: (state, action) => {
+ const user = action.payload.user;
+ const csrf = action.payload.csrf;
+ console.log('setCredentials', user)
+ state.user = user;
+ state.csrf = csrf;
+ }
+ },
+ extraReducers: {
+ [fetchCsrf.fulfilled]: (state, action) => {
+ state.csrf = action.payload
+ },
+ [fetchSession.fulfilled]: (state, action) => {
+ state.isAuthenticated = action.payload.isAuthenticated
+ state.user = action.payload.user
+ },
+ [login.fulfilled]: (state, action) => {
+ console.log('login.fulfilled', action.payload)
+ state.isAuthenticated = action.payload.isAuthenticated;
+ state.user = action.payload.user;
+ state.error = action.payload.error;
+ },
+ [logout.fulfilled]: (state, action) => {
+ state.isAuthenticated = action.payload.isAuthenticated;
+ },
+ }
+});
+
+export const { setCredentials } = slice.actions;
+
+export default slice.reducer;
+
+export const selectCurrentUser = (state) => state.login.user;
+export const selectCsrf = (state) => state.login.csrf;
+export const selectAuthHeaders = (state) => {
+ let headers = {}
+ const csrf = state.login.csrf;
+ if (csrf) {
+ headers["X-CSRFToken"] = csrf;
+ }
+ return headers
+}
+export const isAuthenticated = (state) => state.login.isAuthenticated;
+export const loginError = (state) => state.login.error;
diff --git a/frontend/src/features/menu/AvatarListItem.js b/frontend/src/features/menu/AvatarListItem.js
new file mode 100644
index 00000000..df09523d
--- /dev/null
+++ b/frontend/src/features/menu/AvatarListItem.js
@@ -0,0 +1,78 @@
+import React from "react";
+
+import ListItem from "@mui/material/ListItem";
+import ListItemSecondaryAction from "@mui/material/ListItemSecondaryAction";
+import ListItemIcon from "@mui/material/ListItemIcon";
+import ListItemText from "@mui/material/ListItemText";
+import Checkbox from "@mui/material/Checkbox";
+import Box from "@mui/material/Box";
+import classNames from "classnames";
+import Tooltip from "@mui/material/Tooltip";
+import CircularProgress from "@mui/material/CircularProgress";
+import ListItemAvatar from "@mui/material/ListItemAvatar";
+import Avatar from "@mui/material/Avatar";
+import makeStyles from '@mui/styles/makeStyles';
+
+const useStyles = makeStyles((theme) => ({
+ nested: {
+ paddingLeft: theme.spacing(4),
+ },
+ colorSelected: {
+ backgroundColor: theme.palette.secondary.main,
+ },
+ avatarSmall: {
+ width: theme.spacing(3),
+ height: theme.spacing(3),
+ },
+}));
+
+export default function AvatarListItem({
+ nested,
+ item,
+ selected,
+ handleClick,
+ handleToggle,
+ small,
+ checked,
+ loading,
+}) {
+ const classes = useStyles();
+ const avatarClassName = classNames(
+ small ? classes.avatarSmall : null,
+ selected ? classes.colorSelected : null
+ );
+ const itemClassName = classNames(nested ? classes.nested : null);
+
+ const marginAdjust = -2;
+
+ let avatar = (
+
+ {item.name[0]}
+
+ );
+ if (loading) {
+ avatar = (
+
+
+ );
+ }
+
+ return (
+
+
+ {avatar}
+
+
+ }
+
+
+ );
+}
diff --git a/frontend/src/features/menu/ExpandableListItem.js b/frontend/src/features/menu/ExpandableListItem.js
new file mode 100644
index 00000000..c1981bc1
--- /dev/null
+++ b/frontend/src/features/menu/ExpandableListItem.js
@@ -0,0 +1,168 @@
+import React from "react";
+import { useDispatch } from "react-redux";
+import makeStyles from '@mui/styles/makeStyles';
+import { useSelector } from "react-redux";
+
+import List from "@mui/material/List";
+import ListItem from "@mui/material/ListItem";
+import ListItemIcon from "@mui/material/ListItemIcon";
+import ListItemText from "@mui/material/ListItemText";
+
+import TableChartIcon from "@mui/icons-material/TableChart";
+import AccessibilityIcon from "@mui/icons-material/Accessibility";
+import FunctionsIcon from "@mui/icons-material/Functions";
+
+import CircularProgress from "@mui/material/CircularProgress";
+import Tooltip from "@mui/material/Tooltip";
+
+import Collapse from "@mui/material/Collapse";
+import ExpandLess from "@mui/icons-material/ExpandLess";
+import ExpandMore from "@mui/icons-material/ExpandMore";
+
+import Avatar from "@mui/material/Avatar";
+import ListItemAvatar from "@mui/material/ListItemAvatar";
+import AddIcon from "@mui/icons-material/Add";
+
+import AvatarListItem from "./AvatarListItem";
+
+import { selectItem as selectModellingItem } from "../modelling/modellingSlice"
+import { addNewDataset, selectDatasetById, selectDatasetIds, toggleDataset } from "../datasets/datasetsSlice.js";
+import { addNewPkModel, selectPkModelById, selectPkModelIds, selectWritablePkModelIds, togglePkModel } from "../pkModels/pkModelsSlice.js";
+import { addNewPdModel, selectPdModelById, selectPdModelIds, selectWritablePdModelIds, togglePdModel } from "../pdModels/pdModelsSlice.js";
+import { addNewProtocol, selectProtocolById, selectProtocolIds, toggleProtocol } from "../protocols/protocolsSlice.js";
+import { addNewInference, selectInferenceById, selectInferenceIds, toggleInference } from "../inference/inferenceSlice";
+
+const useStyles = makeStyles((theme) => ({
+ avatarPlusSmall: {
+ width: theme.spacing(3),
+ height: theme.spacing(3),
+ backgroundColor: theme.palette.primary.main,
+ },
+}));
+
+function GenericListItem({id, type, selector, handleToggle, handleClickItem}) {
+ const item = useSelector((state) => selector(state, id))
+ if (!item) {
+ return (null)
+ }
+ const loading = item.status ? item.status === "loading" : false;
+ const simulateLoading = item.simulate
+ ? item.simulate.status === "loading"
+ : false;
+
+ return (
+ handleToggle(item) : null}
+ handleClick={() => handleClickItem(item)}
+ />
+ );
+}
+
+
+export default function ExpandableListItem({
+ text,
+ type,
+ project,
+ disableSave,
+}) {
+ const dispatch = useDispatch();
+ const classes = useStyles();
+ const [open, setOpen] = React.useState(true);
+
+ const handleClick = () => {
+ setOpen(!open);
+ };
+
+ let selectorById = null
+ let selector = null
+ let Icon = null
+ let toggle = null
+ let addNew = null
+ let selectItem = selectModellingItem
+ if (type == 'dataset') {
+ selectorById = selectDatasetById
+ selector = selectDatasetIds
+ Icon = TableChartIcon
+ toggle = toggleDataset
+ addNew = addNewDataset
+ }
+ if (type == 'pk_model') {
+ selectorById = selectPkModelById
+ selector = selectWritablePkModelIds
+ Icon = AccessibilityIcon
+ toggle = togglePkModel
+ addNew = addNewPkModel
+ }
+ if (type == 'pd_model') {
+ selectorById = selectPdModelById
+ selector = selectWritablePdModelIds
+ Icon = FunctionsIcon
+ toggle = togglePdModel
+ addNew = addNewPdModel
+ }
+ if (type == 'protocol') {
+ selector = selectProtocolIds
+ selectorById = selectProtocolById
+ Icon = AccessibilityIcon
+ toggle = toggleProtocol
+ addNew = addNewProtocol
+ }
+ if (type == 'inference') {
+ selector = selectInferenceIds
+ selectorById = selectInferenceById
+ Icon = AccessibilityIcon
+ toggle = null
+ addNew = addNewInference
+ }
+
+ const ids = useSelector(selector);
+ const handleToggle = toggle ? (item) => dispatch(toggle(item)) : null
+ const handleClickItem = (item) => {
+ dispatch(selectItem({type: type, id: item.id}));
+ }
+ const handleNewItem = () => dispatch(addNew(project)).then((arg) => dispatch(selectItem({id: arg.payload.id, type: type})));
+
+ return (
+
+
+
+
+
+
+
+ {ids && ids.map((id) => (
+
+
+
+
+
+
+
+
+ )}
+
+
+
+ );
+}
diff --git a/frontend/src/features/menu/InferenceMenu.js b/frontend/src/features/menu/InferenceMenu.js
new file mode 100644
index 00000000..0f05db86
--- /dev/null
+++ b/frontend/src/features/menu/InferenceMenu.js
@@ -0,0 +1,45 @@
+import React from "react";
+
+import { useSelector } from "react-redux";
+import AccountTreeIcon from "@mui/icons-material/AccountTree";
+
+import List from "@mui/material/List";
+import ListItem from "@mui/material/ListItem";
+import ListItemIcon from "@mui/material/ListItemIcon";
+import ListItemText from "@mui/material/ListItemText";
+
+import Divider from "@mui/material/Divider";
+
+import Inferences from "../inference/Inferences";
+import DraftInferences from "../inference/DraftInferences";
+
+import {
+ selectChosenProject,
+ userHasReadOnlyAccess,
+} from "../projects/projectsSlice.js";
+
+export default function ProjectMenu() {
+ const project = useSelector(selectChosenProject);
+ console.log("got project", project);
+
+ const disableSave = project ? userHasReadOnlyAccess(project) : true;
+
+ const projectName = project ? project.name : "None";
+
+ return (
+
+
+
+
+
+ {project && (
+
+
+ )}
+
+ );
+}
diff --git a/frontend/src/features/menu/LinearProgressWithLabel.js b/frontend/src/features/menu/LinearProgressWithLabel.js
new file mode 100644
index 00000000..a8ab97b4
--- /dev/null
+++ b/frontend/src/features/menu/LinearProgressWithLabel.js
@@ -0,0 +1,19 @@
+import React from "react";
+import Box from "@mui/material/Box";
+import LinearProgress from "@mui/material/LinearProgress";
+import Typography from '@mui/material/Typography';
+
+
+export default function LinearProgressWithLabel(props) {
+ return (
+
+ {`${props.value}%`}
+
+
+
+ );
+}
diff --git a/frontend/src/features/modelling/Chart.js b/frontend/src/features/modelling/Chart.js
new file mode 100644
index 00000000..a03b8eb4
--- /dev/null
+++ b/frontend/src/features/modelling/Chart.js
@@ -0,0 +1,383 @@
+import React from "react";
+import { useSelector } from "react-redux";
+
+import makeStyles from '@mui/styles/makeStyles';
+import List from "@mui/material/List";
+import Alert from '@mui/material/Alert';
+import Box from "@mui/material/Box";
+import Tooltip from "@mui/material/Tooltip";
+import Grid from "@mui/material/Grid";
+import ListItem from "@mui/material/ListItem";
+import ListItemIcon from "@mui/material/ListItemIcon";
+import ListItemText from "@mui/material/ListItemText";
+
+
+
+import { Scatter } from "react-chartjs-2";
+import Header from "../modelling/Header";
+
+import { Chart, registerables, Interaction } from "chart.js";
+import { CrosshairPlugin, Interpolate } from "chartjs-plugin-crosshair";
+import { getColor, getShape } from "./ShapesAndColors";
+import {Typography} from "@mui/material";
+
+Chart.register(...registerables, CrosshairPlugin);
+Interaction.modes.interpolate = Interpolate;
+
+
+export default function ModellingChart({ datasets, pkModels, pdModels, visualHeight }) {
+ let renderChart = true;
+
+ let showRhsAxis = false;
+
+ const biomarkers = useSelector((state) => state.biomarkerTypes.entities);
+ const subjects = useSelector((state) => state.subjects.entities);
+ const variables = useSelector((state) => state.variables.entities);
+ const units = useSelector((state) => state.units.entities);
+
+ let labelsShown = {}
+
+ let xLimits = [0, 0];
+ let updateXLimits = (data) => {
+ xLimits[0] = Math.min(xLimits[0], Math.min(...data));
+ xLimits[1] = Math.max(xLimits[1], Math.max(...data));
+ };
+
+ const getChartData = (model) => {
+ console.log("getChartData");
+ if (!model.simulate) {
+ return {};
+ }
+ let model_simulate = { ...model.simulate };
+ delete model_simulate.status;
+ const have_all_variables =
+ Object.keys(model_simulate).filter((id) => id in variables).length ===
+ Object.keys(model_simulate).length;
+ if (!have_all_variables) {
+ return {};
+ }
+ const time_id = Object.keys(model_simulate).filter(
+ (id) => variables[id].binding === "time"
+ )[0];
+ const time_variable = variables[time_id]
+ const time_unit = time_variable ? units[time_variable.unit] : null;
+
+ return Object.entries(model_simulate)
+ .map(([variable_id, data]) => {
+ const variable = variables[variable_id];
+ const unit = units[variable.unit];
+ console.log("doing variable", variable, variable_id);
+ const color = getColor(variable.color);
+ if (!variable.display) {
+ return null;
+ }
+ const yAxisID = variable.axis ? "yRhs" : "yLhs";
+ if (variable.axis) {
+ showRhsAxis = true;
+ }
+ // chartjs crashes if there are identical labels
+ let label = `${variable.qname} [${unit ? unit.symbol : ''}]`;
+ if (label in labelsShown) {
+ label = `${label}${labelsShown[label]}`
+ labelsShown[label] += 1
+ } else {
+ labelsShown[label] = 1
+ }
+ updateXLimits(model_simulate[time_id]);
+ return {
+ yAxisID: yAxisID,
+ type: "line",
+ label: label,
+ borderColor: color,
+ backgroundColor: color,
+ showLine: true,
+ fill: false,
+ lineTension: 0,
+ interpolate: true,
+ myMetadata: {
+ ylabel: label,
+ xlabel: `${model.name}.time [${time_unit ? time_unit.symbol : ''}]`,
+ yunit: unit,
+ xunit: time_unit,
+ },
+ data: data.map((y, i) => ({ x: model_simulate[time_id][i], y: y })),
+ };
+ })
+ .filter((x) => x);
+ };
+
+ const getChartDataDataset = (dataset) => {
+ return dataset.biomarker_types
+ .map((id) => {
+ const biomarker = biomarkers[id];
+ if (!biomarker) {
+ return null;
+ }
+ const display_unit = units[biomarker.display_unit];
+ const display_time_unit = units[biomarker.display_time_unit];
+ const subjectsDisplay = biomarker.data.subjects.map((id) =>
+ subjects[id] ? subjects[id].display : false
+ );
+ const subjectsDisplayFilter = (_, i) => subjectsDisplay[i];
+ const times = biomarker.data.times.filter(subjectsDisplayFilter);
+ const values = biomarker.data.values.filter(subjectsDisplayFilter);
+ const color = getColor(biomarker.color);
+ const pointStyle = biomarker.data.subjects
+ .filter(subjectsDisplayFilter)
+ .map((id) => getShape(subjects[id].shape));
+ if (!biomarker.display) {
+ return null;
+ }
+ if (values.length === 0) {
+ return null;
+ }
+ const yAxisID = biomarker.axis ? "yRhs" : "yLhs";
+ if (biomarker.axis) {
+ showRhsAxis = true;
+ }
+ const label = `${dataset.name}.${biomarker.name} [${display_unit ? display_unit.symbol : ''}]`;
+ updateXLimits(times);
+ return {
+ yAxisID: yAxisID,
+ label: label,
+ pointStyle: pointStyle,
+ borderColor: color,
+ backgroundColor: color,
+ myMetadata: {
+ ylabel: label,
+ xlabel: `${dataset.name}.time [${display_time_unit ? display_time_unit.symbol : ''}]`,
+ yunit: display_unit,
+ xunit: display_time_unit,
+ },
+ data: values.map((y, i) => ({ x: times[i], y: y })),
+ };
+ })
+ .filter((x) => x);
+ };
+
+ const getChartDataProtocol = (dataset) => {
+ return dataset.protocols
+ .map((protocol, index) => {
+ const display_unit = units[protocol.amount_unit];
+ const display_time_unit = units[protocol.time_unit];
+ const subjectsDisplay = protocol.subjects.map(id => subjects[id] ? subjects[id].display : false)
+ console.log("subjectsDisplay", subjectsDisplay)
+ const protocolDisplay = subjectsDisplay.some((x) => x);
+ if (!protocolDisplay) {
+ return null;
+ }
+ let times = protocol.doses.map(dose => [dose.start_time, dose.start_time, dose.start_time + dose.duration, dose.start_time + dose.duration]).flat();
+ let values = protocol.doses.map(dose => [0, dose.amount, dose.amount, 0]).flat();
+ times.unshift(xLimits[0]);
+ times.push(xLimits[1]);
+ values.unshift(0);
+ values.push(0);
+ console.log("times", times)
+ console.log("values", values)
+ const color = getColor(index);
+ if (values.length === 0) {
+ return null;
+ }
+ const yAxisID = "yLhs";
+ const label = `${protocol.name} [${display_unit ? display_unit.symbol : ''}]`;
+ return {
+ yAxisID: yAxisID,
+ label: label,
+ type: "line",
+ fill: true,
+ lineTension: 0,
+ interpolate: true,
+ borderColor: color,
+ backgroundColor: color,
+ myMetadata: {
+ ylabel: label,
+ xlabel: `${protocol.name}.time [${display_time_unit ? display_time_unit.symbol : ''}]`,
+ yunit: display_unit,
+ xunit: display_time_unit,
+ },
+ data: values.map((y, i) => ({ x: times[i], y: y })),
+ };
+ })
+ .filter((x) => x);
+ };
+
+ const data = {
+ datasets: [
+ ...datasets
+ .map((d) => getChartDataDataset(d))
+ .flat()
+ .flat(),
+ ...pkModels.map((m) => getChartData(m)).flat(),
+ ...pdModels.map((m) => getChartData(m)).flat(),
+ ],
+ };
+
+ const data_protocols = {
+ datasets: [
+ ...datasets.map((d) => getChartDataProtocol(d)).flat().flat(),
+ ]
+ }
+
+ const showProtocols = datasets.length > 0;
+
+ const y_unit_symbols = data.datasets.reduce((sum, dataset) => {
+ if (!dataset?.myMetadata) {
+ return sum;
+ }
+ const unit = dataset.myMetadata.yunit;
+ sum.add(unit ? unit.symbol : '');
+ return sum;
+ }, new Set());
+
+ const y_amount_unit_symbols = data_protocols.datasets.reduce((sum, dataset) => {
+ if (!dataset?.myMetadata) {
+ return sum;
+ }
+ const unit = dataset.myMetadata.yunit;
+ sum.add(unit ? unit.symbol : '');
+ return sum;
+ }, new Set());
+
+ const x_unit_symbols = data.datasets.reduce((sum, dataset) => {
+ if (!dataset?.myMetadata) {
+ return sum;
+ }
+ const unit = dataset.myMetadata.xunit;
+ sum.add(unit ? unit.symbol : '');
+ return sum;
+ }, new Set());
+
+ const incompatible_y_unit = y_unit_symbols.size > 1;
+ const incompatible_x_unit = x_unit_symbols.size > 1;
+
+ const list_of_y_unit = new Array(...y_unit_symbols).join(', ');
+ const list_of_y_amount_unit = new Array(...y_amount_unit_symbols).join(', ');
+ const list_of_x_unit = new Array(...x_unit_symbols).join(', ');
+
+ let crosshair = {
+ line: {
+ color: '#F66', // crosshair line color
+ width: 1 // crosshair line width
+ },
+ sync: {
+ enabled: true, // enable trace line syncing with other charts
+ suppressTooltips: false // suppress tooltips when showing a synced tracer
+ },
+ zoom: {
+ enabled: true, // enable zooming
+ zoomboxBackgroundColor: 'rgba(66,133,244,0.2)', // background color of zoom box
+ zoomboxBorderColor: '#48F', // border color of zoom box
+ zoomButtonText: 'Reset Zoom', // reset zoom button text
+ zoomButtonClass: 'reset-zoom', // reset zoom button class
+ },
+ }
+
+ let plugins = {
+ legend: {
+ labels: {
+ usePointStyle: true,
+ },
+ },
+ tooltip: {
+ mode: "interpolate",
+ callbacks: {
+ title: function (a, d) {
+ return a[0].element.x.toPrecision(4);
+ },
+ label: function (d) {
+ return d.dataset.label + ": " + d.element.y.toPrecision(4);
+ },
+ },
+ },
+ crosshair,
+ };
+
+ let options_protocols = {
+ animation: {
+ duration: 0,
+ },
+ responsive: true,
+ maintainAspectRatio: false,
+ scales: {
+ x: {
+ type: "linear",
+ title: {
+ text: `Time [${list_of_x_unit}]`,
+ display: false,
+ },
+ },
+ yLhs: {
+ position: "left",
+ title: {
+ text: `Dose Amount [${list_of_y_amount_unit}]`,
+ display: true,
+ }
+ }
+ },
+ plugins,
+ }
+
+ let options = {
+ animation: {
+ duration: 0,
+ },
+ responsive: true,
+ maintainAspectRatio: false,
+ scales: {
+ x: {
+ type: "linear",
+ title: {
+ text: `Time [${list_of_x_unit}]`,
+ display: true,
+ },
+ },
+ yLhs: {
+ position: "left",
+ title: {
+ text: `Data Variable / Model Output [${list_of_y_unit}]`,
+ display: true,
+ },
+ },
+ },
+ plugins,
+ };
+
+ if (showRhsAxis) {
+ options.scales["yRhs"] = {
+ position: "right",
+ title: {
+ text: "Data Variable / Model Output (units defined above)",
+ display: true,
+ },
+ };
+ }
+
+ const chartVisualHeight = visualHeight * 3.0 / 4.0;
+ const chartVisualHeightStr = `${chartVisualHeight}vh}`;
+ const protocolVisualHeight = visualHeight * 1.0 / 4.0;
+ const protocolVisualHeightStr = `${protocolVisualHeight}vh}`;
+
+ console.log('data', data, options, renderChart)
+ return (
+
+
+ {renderChart &&
+ {showProtocols &&
+
+ {renderChart &&
+ }
+ {incompatible_y_unit &&
+
+ Different units on y-axis
+
+ }
+ {incompatible_x_unit &&
+
+ Different units on x-axis
+
+ }
+
+ );
+}
diff --git a/frontend/src/features/modelling/ChartController.js b/frontend/src/features/modelling/ChartController.js
new file mode 100644
index 00000000..b1513307
--- /dev/null
+++ b/frontend/src/features/modelling/ChartController.js
@@ -0,0 +1,3 @@
+export default function ChartController() {
+ return null;
+}
diff --git a/frontend/src/features/modelling/Footer.js b/frontend/src/features/modelling/Footer.js
new file mode 100644
index 00000000..78b47bfb
--- /dev/null
+++ b/frontend/src/features/modelling/Footer.js
@@ -0,0 +1,66 @@
+import React, { useEffect } from "react";
+import Paper from "@mui/material/Paper";
+import makeStyles from '@mui/styles/makeStyles';
+import Button from "@mui/material/Button";
+import Toolbar from "@mui/material/Toolbar";
+import Typography from "@mui/material/Typography";
+
+const useStyles = makeStyles((theme) => ({
+ controls: {
+ justifyContent: 'center',
+ "& > *": {
+ margin: theme.spacing(1),
+ },
+ },
+ toolbar: {
+ marginTop: theme.spacing(1),
+ backgroundColor: theme.palette.primary.main,
+ position: 'sticky',
+ bottom: 0,
+ borderRadius: '0 0 5px 5px',
+ }
+}));
+
+export default function Footer({ buttons, disableSave, variant }) {
+ const classes = useStyles();
+ const button = null
+ const createButton = (button, i) => {
+ if (button.variant == 'fileUpload') {
+ return (
+
+ {button.label}
+
+ )
+ } else {
+ return(
+
+ {button.label}
+
+
+ )
+ }
+ };
+
+ return (
+
+
+ {buttons.map(createButton)}
+
+
+ )
+}
diff --git a/frontend/src/features/modelling/Header.js b/frontend/src/features/modelling/Header.js
new file mode 100644
index 00000000..cc17b990
--- /dev/null
+++ b/frontend/src/features/modelling/Header.js
@@ -0,0 +1,31 @@
+import React, { useEffect } from "react";
+import Paper from "@mui/material/Paper";
+import makeStyles from '@mui/styles/makeStyles';
+import Toolbar from "@mui/material/Toolbar";
+import Typography from "@mui/material/Typography";
+
+const useStyles = makeStyles((theme) => ({
+ topToolbar: {
+ backgroundColor: theme.palette.primary.main,
+ position: 'sticky',
+ top: 0,
+ borderRadius: '5px 5px 0 0',
+ zIndex: 10,
+ marginBottom: theme.spacing(1),
+ },
+ header: {
+ fontWeight:'bold',
+ color: theme.palette.primary.contrastText,
+ },
+}));
+
+export default function Header({ title }) {
+ const classes = useStyles();
+ return (
+
+
+ {title}
+
+
+ )
+}
diff --git a/frontend/src/features/modelling/Modelling.js b/frontend/src/features/modelling/Modelling.js
new file mode 100644
index 00000000..cb9f554a
--- /dev/null
+++ b/frontend/src/features/modelling/Modelling.js
@@ -0,0 +1,277 @@
+import React from "react";
+import { useDispatch, useSelector } from "react-redux";
+import Paper from "@mui/material/Paper";
+import Grid from "@mui/material/Grid";
+import PkDetail from "../pkModels/PkDetail";
+import AccountTreeIcon from "@mui/icons-material/AccountTree";
+import PdDetail from "../pdModels/PdDetail";
+import Toolbar from '@mui/material/Toolbar';
+import ProtocolDetail from "../protocols/ProtocolDetail";
+import DatasetDetail from "../datasets/DatasetDetail";
+import Chart from "./Chart";
+import Drawer from "@mui/material/Drawer";
+import Accordion from "@mui/material/Accordion";
+import AccordionSummary from "@mui/material/AccordionSummary";
+import AccordionDetails from "@mui/material/AccordionDetails";
+import Box from "@mui/material/Box";
+import CircularProgress from "@mui/material/CircularProgress";
+import ExpandMoreIcon from "@mui/icons-material/ExpandMore";
+import Typography from "@mui/material/Typography";
+import List from "@mui/material/List";
+import ListItem from "@mui/material/ListItem";
+import ListItemIcon from "@mui/material/ListItemIcon";
+import ListItemText from "@mui/material/ListItemText";
+
+import makeStyles from '@mui/styles/makeStyles';
+
+import Header from "../modelling/Header";
+import Footer from "../modelling/Footer";
+import { selectChosenProject, userHasReadOnlyAccess } from "../projects/projectsSlice.js";
+
+import { selectChosenDatasets, selectChosenDatasetProtocols, selectDatasetById } from "../datasets/datasetsSlice.js";
+
+import { selectChosenPdModels, selectPdModelById } from "../pdModels/pdModelsSlice.js";
+
+import { selectChosenPkModels, selectPkModelById } from "../pkModels/pkModelsSlice.js";
+
+import { selectChosenProtocols, selectProtocolById } from "../protocols/protocolsSlice.js";
+
+import { clearSelectItem } from "./modellingSlice"
+
+import DatasetProtocols from "../protocols/DatasetProtocols";
+import ProjectDetail from "../projects/ProjectDetail";
+import ExpandableListItem from "../menu/ExpandableListItem";
+
+const drawerWidth = 250;
+
+const useStyles = makeStyles((theme) => ({
+ drawer: {
+ width: drawerWidth,
+ flexShrink: 0,
+ '& .MuiDrawer-paper': {
+ width: drawerWidth,
+ boxSizing: 'border-box',
+ },
+ },
+ main: {
+ marginLeft: drawerWidth,
+ flexGrow: 1,
+ },
+ paperChart: {
+ padding: theme.spacing(2),
+ maxHeight: '90vh', overflow: 'auto'
+ },
+ chart: {
+ height: "50vh",
+ width: "100%",
+ },
+ protocolChart: {
+ height: "40vh",
+ width: "100%",
+ marginTop: theme.spacing(2),
+ },
+ mmt_box: {
+ width: "100%",
+ padding: theme.spacing(2),
+ maxHeight: '23vh', overflow: 'auto'
+ },
+ mmt: {
+ whiteSpace: 'pre-wrap'
+ },
+}));
+
+function Mmt({ item, project }) {
+ const classes = useStyles();
+ console.log('mmt', item.mmt)
+ return (
+
+
+
+
+ {item.mmt}
+
+
+
+
+ )
+}
+
+function ModellingMenu({ project }) {
+ const readOnly = useSelector((state) => userHasReadOnlyAccess(state, project));
+ const disableSave = project ? readOnly : true;
+ const dispatch = useDispatch();
+ const handleProjectClick = () => dispatch(clearSelectItem());
+ return (
+
+
+
+
+
+
+ );
+}
+
+function ModellingChart({ project }) {
+ const classes = useStyles();
+ const chosenDatasets = useSelector(selectChosenDatasets);
+ const chosenPkModels = useSelector(selectChosenPkModels);
+ const chosenPdModels = useSelector(selectChosenPdModels);
+ const chosenDatasetProtocols = useSelector(selectChosenDatasetProtocols);
+
+ let showChart = true;
+ if (
+ !chosenDatasets ||
+ !chosenPkModels ||
+ !chosenPdModels
+ ) {
+ showChart = false;
+ }
+ if (
+ chosenDatasets.length === 0 &&
+ chosenPkModels.length === 0 &&
+ chosenPdModels.length === 0
+ ) {
+ showChart = false;
+ }
+
+ if (!showChart) {
+ return (
+ Choose a dataset or model to visualise
+ )
+ }
+
+ console.log('Chosendatasets', chosenDatasets)
+ console.log('chosenPkModels', chosenPkModels)
+ console.log('chosenPdModels', chosenPdModels)
+
+ return (
+
+
+
+ );
+}
diff --git a/frontend/src/features/pdModels/pdModelsSlice.js b/frontend/src/features/pdModels/pdModelsSlice.js
new file mode 100644
index 00000000..0bda2443
--- /dev/null
+++ b/frontend/src/features/pdModels/pdModelsSlice.js
@@ -0,0 +1,250 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+import { fetchVariablesByPdModel } from "../variables/variablesSlice";
+import { setSelected } from "../modelling/modellingSlice";
+import { fetchUnitsByPdModel } from "../projects/unitsSlice";
+
+const pdModelsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = pdModelsAdapter.getInitialState({
+ status: "idle",
+ errorFetch: null,
+});
+
+export const fetchPdModels = createAsyncThunk(
+ "pdModels/fetchPdModels",
+ async (project_id, { dispatch, getState }) => {
+ let response = await api.get(
+ `/api/pharmacodynamic/?project_id=${project_id}`, getState().login.csrf
+ );
+ for (var i = 0; i < response.length; i++) {
+ if (!response[i].read_only) {
+ dispatch(fetchPdModelSimulateById(response[i].id));
+ }
+ }
+ return response;
+ }
+);
+
+export const fetchPdModelById = createAsyncThunk(
+ "pdModels/fetchPdModelById",
+ async (model_id, { dispatch, getState }) => {
+ let response = await api.get(`/api/pharmacodynamic/${model_id}/`, getState().login.csrf);
+ dispatch(fetchVariablesByPdModel(response.id));
+ dispatch(fetchUnitsByPdModel(response.id));
+ dispatch(fetchPdModelSimulateById(response.id));
+ return response;
+ }
+);
+
+export const fetchPdModelSimulateById = createAsyncThunk(
+ "pdModels/fetchPdModelSimulateById",
+ async (model_id, {getState}) => {
+ const response = await api.post(
+ `/api/pharmacodynamic/${model_id}/simulate`, getState().login.csrf, {}
+ );
+ return response;
+ }
+);
+
+export const addNewPdModel = createAsyncThunk(
+ "pdModels/addNewPdModel",
+ async (project, { dispatch, getState }) => {
+ const initialPdModel = {
+ name: "new",
+ project: project.id,
+ };
+ let pdModel = await api.post("/api/pharmacodynamic/", getState().login.csrf, initialPdModel);
+
+ dispatch(fetchVariablesByPdModel(pdModel.id));
+ dispatch(fetchUnitsByPdModel(pdModel.id));
+ dispatch(fetchPdModelSimulateById(pdModel.id));
+
+ return pdModel;
+ }
+);
+
+export const deletePdModel = createAsyncThunk(
+ "pdModels/deletePdModel",
+ async (pdModelId, { dispatch, getState }) => {
+ let { modelling } = getState()
+ if (modelling.selectedType === 'pd_model' && modelling.selectedId === pdModelId) {
+ dispatch(setSelected({id: null, type: null}))
+ }
+ await api.delete(`/api/pharmacodynamic/${pdModelId}`, getState().login.csrf);
+ return pdModelId;
+ }
+);
+
+export const uploadPdSbml = createAsyncThunk(
+ "pdModels/uploadPdSbml",
+ async ({ id, sbml }, { rejectWithValue, dispatch, getState }) => {
+ try {
+ await api.putMultiPart(`/api/pharmacodynamic/${id}/sbml/`, getState().login.csrf, { sbml });
+ } catch (error) {
+ return rejectWithValue(error);
+ }
+ let pdModel = await api.get(`/api/pharmacodynamic/${id}`, getState().login.csrf);
+ dispatch(fetchVariablesByPdModel(pdModel.id));
+ dispatch(fetchUnitsByPdModel(pdModel.id));
+ dispatch(fetchPdModelSimulateById(pdModel.id));
+ return pdModel;
+ }
+);
+
+export const uploadPdMmt = createAsyncThunk(
+ "pdModels/uploadPdMmt",
+ async ({ id, mmt }, { rejectWithValue, dispatch, getState }) => {
+ try {
+ await api.putMultiPart(`/api/pharmacodynamic/${id}/mmt/`, getState().login.csrf, { mmt });
+ } catch (error) {
+ return rejectWithValue(error);
+ }
+ let pdModel = await api.get(`/api/pharmacodynamic/${id}`, getState().login.csrf);
+ console.log('pdModel', pdModel)
+ dispatch(fetchVariablesByPdModel(pdModel.id));
+ dispatch(fetchUnitsByPdModel(pdModel.id));
+ dispatch(fetchPdModelSimulateById(pdModel.id));
+ return pdModel;
+ }
+);
+
+export const setPdVariablesByInference = createAsyncThunk(
+ "pdModels/setVariablesByInference",
+ async ({ id, inference_id }, { rejectWithValue, dispatch, getState }) => {
+ const pdModel = await api.put(`/api/pharmacodynamic/${id}/set_variables_from_inference/`, getState().login.csrf, { inference_id});
+ dispatch(fetchVariablesByPdModel(pdModel.id));
+ dispatch(fetchPdModelSimulateById(pdModel.id));
+ return pdModel;
+ }
+);
+
+export const updatePdModel = createAsyncThunk(
+ "pdModels/updatePdModel",
+ async (pdModel, { dispatch, getState }) => {
+ let newPdModel = await api.put(
+ `/api/pharmacodynamic/${pdModel.id}/`, getState().login.csrf,
+ pdModel
+ );
+ dispatch(fetchPdModelSimulateById(newPdModel.id));
+ return newPdModel;
+ }
+);
+
+export const pdModelsSlice = createSlice({
+ name: "pdModels",
+ initialState,
+ reducers: {
+ togglePdModel(state, action) {
+ let pdModel = state.entities[action.payload.id];
+ pdModel.chosen = !pdModel.chosen;
+ },
+ setSelectPdModel(state, action) {
+ let pdModel = state.entities[action.payload.id];
+ pdModel.selected = action.payload.select;
+ },
+ setPdModelError(state, action) {
+ let pdModel = state.entities[action.payload.id];
+ pdModel.error = action.payload.error;
+ },
+ addPdModels: pdModelsAdapter.upsertMany,
+ },
+ extraReducers: {
+ [fetchPdModels.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchPdModels.rejected]: (state, action) => {
+ state.status = "failed";
+ state.errorFetch = action.error.message;
+ },
+ [fetchPdModels.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ pdModelsAdapter.setAll(state, action.payload);
+ },
+
+
+ [fetchPdModelById.fulfilled]: pdModelsAdapter.upsertOne,
+ [fetchPdModelSimulateById.fulfilled]: pdModelsAdapter.upsertOne,
+ [fetchPdModelSimulateById.pending]: (state, action) => {
+ if (state.ids.includes(action.meta.arg)) {
+ state.entities[action.meta.arg]["simulate"] = {
+ status: "loading",
+ };
+ }
+ },
+ [fetchPdModelSimulateById.fulfilled]: (state, action) => {
+ if (state.ids.includes(action.meta.arg)) {
+ state.entities[action.meta.arg].simulate = {
+ ...action.payload,
+ status: "succeeded",
+ };
+ }
+ },
+ [fetchPdModelSimulateById.rejected]: (state, action) => {
+ if (state.ids.includes(action.meta.arg)) {
+ state.entities[action.meta.arg].simulate = {
+ status: "failed",
+ };
+ }
+ },
+ [addNewPdModel.fulfilled]: pdModelsAdapter.addOne,
+ [updatePdModel.fulfilled]: pdModelsAdapter.upsertOne,
+ [setPdVariablesByInference.fulfilled]: pdModelsAdapter.upsertOne,
+ [deletePdModel.fulfilled]: pdModelsAdapter.removeOne,
+ [uploadPdSbml.pending]: (state, action) => {
+ state.entities[action.meta.arg.id].status = "loading";
+ state.entities[action.meta.arg.id].errors = [];
+ },
+ [uploadPdSbml.rejected]: (state, action) => {
+ state.entities[action.meta.arg.id].status = "failed";
+ state.entities[action.meta.arg.id].errors = action.payload.sbml;
+ },
+ [uploadPdSbml.fulfilled]: (state, action) => {
+ state.entities[action.meta.arg.id].status = "failed";
+ pdModelsAdapter.upsertOne(state, action);
+ },
+ [uploadPdMmt.pending]: (state, action) => {
+ state.entities[action.meta.arg.id].status = "loading";
+ state.entities[action.meta.arg.id].status = "failed";
+ state.entities[action.meta.arg.id].errors = [];
+ },
+ [uploadPdMmt.rejected]: (state, action) => {
+ state.entities[action.meta.arg.id].status = "failed";
+ console.log('rejected', action)
+ state.entities[action.meta.arg.id].errors = action.payload.mmt;
+ },
+ [uploadPdMmt.fulfilled]: (state, action) => {
+ state.entities[action.meta.arg.id].status = "failed";
+ pdModelsAdapter.upsertOne(state, action);
+ },
+ },
+});
+
+export const { togglePdModel, setSelectPdModel, addPdModels } = pdModelsSlice.actions;
+
+export default pdModelsSlice.reducer;
+
+export const {
+ selectAll: selectAllPdModels,
+ selectById: selectPdModelById,
+ selectIds: selectPdModelIds,
+} = pdModelsAdapter.getSelectors((state) => state.pdModels);
+
+export const selectChosenPdModels = (state) =>
+ selectAllPdModels(state).filter((pdModel) => pdModel.chosen);
+
+
+export const selectWritablePdModels = (state) =>
+ selectAllPdModels(state).filter((pdModel) => !pdModel.read_only);
+
+export const selectWritablePdModelIds = (state) =>
+ selectAllPdModels(state).filter((pdModel) => !pdModel.read_only).map(pdModel => pdModel.id);
+
+export const selectReadOnlyPdModels = (state) =>
+ selectAllPdModels(state).filter((pdModel) => pdModel.read_only);
diff --git a/frontend/src/features/pkModels/PkDetail.js b/frontend/src/features/pkModels/PkDetail.js
new file mode 100644
index 00000000..2bfa5669
--- /dev/null
+++ b/frontend/src/features/pkModels/PkDetail.js
@@ -0,0 +1,305 @@
+import React, { useEffect, useState } from "react";
+import { useSelector, useDispatch } from "react-redux";
+import Button from "@mui/material/Button";
+import List from "@mui/material/List";
+import Box from "@mui/material/Box";
+import IconButton from "@mui/material/IconButton";
+import Grid from "@mui/material/Grid";
+import ListItem from "@mui/material/ListItem";
+import Accordion from "@mui/material/Accordion";
+import AccordionSummary from "@mui/material/AccordionSummary";
+import AccordionDetails from "@mui/material/AccordionDetails";
+import Paper from "@mui/material/Paper";
+import ExpandMoreIcon from "@mui/icons-material/ExpandMore";
+import AddIcon from "@mui/icons-material/Add";
+import AppBar from "@mui/material/AppBar";
+import BottomNavigation from "@mui/material/BottomNavigation";
+import BottomNavigationAction from "@mui/material/BottomNavigationAction";
+import Toolbar from "@mui/material/Toolbar";
+import DeleteIcon from "@mui/icons-material/Delete";
+
+import { useForm, useFieldArray } from "react-hook-form";
+import makeStyles from '@mui/styles/makeStyles';
+import Typography from "@mui/material/Typography";
+
+
+import InferenceListDialog from "../inference/InferenceListDialog";
+import ComponentForm from "../forms/ComponentForm";
+import Header from "../modelling/Header";
+import Footer from "../modelling/Footer";
+import { FormTextField, FormSelectField } from "../forms/FormComponents";
+
+import { selectAllBasePkModels } from "../pkModels/basePkModelsSlice.js";
+
+import { selectAllDatasets } from "../datasets/datasetsSlice.js";
+
+import { selectAllProtocols } from "../protocols/protocolsSlice.js";
+
+import { updatePkModel, deletePkModel, setPkVariablesByInference } from "../pkModels/pkModelsSlice.js";
+
+import { selectAllPdModels } from "../pdModels/pdModelsSlice.js";
+
+import { userHasReadOnlyAccess } from "../projects/projectsSlice";
+
+import {
+ selectVariablesByDosedPkModel,
+} from "../variables/variablesSlice.js";
+
+
+export default function PkDetail({ project, pk_model }) {
+ const mappings_no_null = pk_model.mappings.map(m =>
+ Object.keys(m).reduce((sum, key) => {
+ sum[key] = m[key] || ""
+ return sum
+ }, {}))
+
+ const pk_model_no_null = Object.keys(pk_model).reduce((sum, key) => {
+ if (key === 'mappings') {
+ sum[key] = mappings_no_null
+ } else if (key === 'datetime') {
+ sum[key] = pk_model[key]
+ } else if (pk_model[key] === null) {
+ sum[key] = ""
+ } else {
+ sum[key] = pk_model[key]
+ }
+ return sum
+ }, {})
+ console.log('pk_model_no_null', pk_model_no_null)
+ const { control, handleSubmit, reset } = useForm({
+ defaultValues: pk_model_no_null,
+ });
+ const dispatch = useDispatch();
+
+ const {
+ fields: mappings,
+ append: mappingsAppend,
+ remove: mappingsRemove,
+ } = useFieldArray({
+ control,
+ name: `mappings`,
+ });
+
+ const handleNewMapping = () => mappingsAppend(
+ { pkpd_model: pk_model.id, pk_variable: '', pd_variable: '' }
+ )
+
+ const basePkModels = useSelector(selectAllBasePkModels);
+ const protocols = useSelector(selectAllProtocols);
+ const datasets = useSelector(selectAllDatasets);
+ const pdModels = useSelector(selectAllPdModels);
+ const pd_model_options = pdModels.map((pd_model) => ({
+ key: pd_model.name,
+ value: pd_model.id,
+ })).concat([{key: 'None', value: ''}]);
+
+ const variables = useSelector((state) => {
+ return selectVariablesByDosedPkModel(state, pk_model.id);
+ });
+ const variablesOptions = variables?.map(v => ({
+ key: v.qname, value: v.id
+ }))
+
+ useEffect(() => {
+ reset(pk_model_no_null);
+ }, [reset, pk_model]);
+
+ const handlePkDelete = () => {
+ dispatch(deletePkModel(pk_model.id));
+ };
+
+
+ const [openInferenceDialog, setOpenInferenceDialog] = useState(false);
+
+ const handleCloseInferenceDialog = (inference) => {
+ if (inference) {
+ dispatch(setPkVariablesByInference({id: pk_model.id, inference_id: inference.id}));
+ }
+ setOpenInferenceDialog(false)
+ }
+
+ const handleSetVariablesFromInference = () => {
+ setOpenInferenceDialog(true);
+ };
+
+ const onSubmit = (values) => {
+ console.log('submit', values)
+ dispatch(updatePkModel(values));
+ };
+
+ const base_pk_model_options = basePkModels.filter(pk => !pk.read_only).map((pk) => ({
+ key: pk.name,
+ value: pk.id,
+ }));
+
+ let protocol_options = [];
+ protocol_options = protocol_options.concat(
+ protocols.map((protocol) => ({ key: protocol.name, value: protocol.id }))
+ );
+ console.log('pk_model', pk_model)
+ for (let i = 0; i < datasets.length; i++) {
+ const dataset_protocols = datasets[i].protocols.map((protocol) => ({
+ key: protocol.name,
+ value: protocol.id,
+ }));
+ protocol_options = protocol_options.concat(dataset_protocols);
+ }
+
+ const dose_compartment_options = pk_model.components.map(c => (
+ { key: c.name, value: c.name }
+ ));
+
+ const disableSave = useSelector(state => userHasReadOnlyAccess(state, project));
+
+ return (
+
+
+
+ );
+}
diff --git a/frontend/src/features/pkModels/basePkModelsSlice.js b/frontend/src/features/pkModels/basePkModelsSlice.js
new file mode 100644
index 00000000..52a5083c
--- /dev/null
+++ b/frontend/src/features/pkModels/basePkModelsSlice.js
@@ -0,0 +1,53 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+
+import { api } from "../../Api";
+
+const basePkModelsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = basePkModelsAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchBasePkModels = createAsyncThunk(
+ "basePkModels/fetchBasePkModels",
+ async () => {
+ const response = await api.get(`/api/pharmacokinetic/`);
+ return response;
+ }
+);
+
+export const basePkModelsSlice = createSlice({
+ name: "basePkModels",
+ initialState,
+ reducers: {},
+ extraReducers: {
+ [fetchBasePkModels.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchBasePkModels.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchBasePkModels.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ basePkModelsAdapter.setAll(state, action.payload);
+ },
+ },
+});
+
+// export const {} = basePkModelsSlice.actions
+
+export default basePkModelsSlice.reducer;
+
+export const {
+ selectAll: selectAllBasePkModels,
+ selectById: selectBasePkModelById,
+ selectIds: selectBasePkModelIds,
+} = basePkModelsAdapter.getSelectors((state) => state.basePkModels);
diff --git a/frontend/src/features/pkModels/pkModelsSlice.js b/frontend/src/features/pkModels/pkModelsSlice.js
new file mode 100644
index 00000000..327cf895
--- /dev/null
+++ b/frontend/src/features/pkModels/pkModelsSlice.js
@@ -0,0 +1,199 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+
+import { api } from "../../Api";
+import { fetchVariablesByPkModel } from "../variables/variablesSlice";
+import { setSelected } from "../modelling/modellingSlice";
+import { fetchUnitsByPkModel } from "../projects/unitsSlice";
+
+export const pkModelsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = pkModelsAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchPkModels = createAsyncThunk(
+ "pkModels/fetchPkModels",
+ async (project_id, { dispatch, getState }) => {
+ const response = await api.get(
+ `/api/dosed_pharmacokinetic/?project_id=${project_id}`, getState().login.csrf
+ );
+ for (var i = 0; i < response.length; i++) {
+ if (!response[i].read_only) {
+ dispatch(fetchPkModelSimulateById(response[i].id));
+ }
+ }
+ return response;
+ }
+);
+
+export const fetchPkModelById = createAsyncThunk(
+ "pkModels/fetchPkModelById",
+ async (model_id, { dispatch, getState }) => {
+ let response = await api.get(`/api/dosed_pharmacokinetic/${model_id}/`, getState().login.csrf);
+ dispatch(fetchVariablesByPkModel(response.id));
+ dispatch(fetchUnitsByPkModel(response.id));
+ dispatch(fetchPkModelSimulateById(response.id));
+ return response;
+ }
+);
+
+export const fetchPkModelSimulateById = createAsyncThunk(
+ "pkModels/fetchPkModelSimulateById",
+ async (model_id, { dispatch, getState }) => {
+ const response = await api.post(
+ `/api/dosed_pharmacokinetic/${model_id}/simulate`, getState().login.csrf
+ );
+ return response;
+ }
+);
+
+export const setPkVariablesByInference = createAsyncThunk(
+ "pkModels/setVariablesByInference",
+ async ({ id, inference_id}, { rejectWithValue, dispatch, getState }) => {
+ const pkModel = await api.put(`/api/dosed_pharmacokinetic/${id}/set_variables_from_inference/`, getState().login.csrf, { inference_id });
+ dispatch(fetchVariablesByPkModel(pkModel.id));
+ dispatch(fetchPkModelSimulateById(pkModel.id));
+ return pkModel;
+ }
+);
+
+export const deletePkModel = createAsyncThunk(
+ "pkModels/deletePkModel",
+ async (pkModelId, { dispatch, getState }) => {
+ let { modelling } = getState()
+ if (modelling.selectedType === 'pk_model' && modelling.selectedId === pkModelId) {
+ await dispatch(setSelected({id: null, type: null}))
+ }
+ await api.delete(`/api/dosed_pharmacokinetic/${pkModelId}`, getState().login.csrf);
+ return pkModelId;
+ }
+);
+
+export const addNewPkModel = createAsyncThunk(
+ "pkModels/addNewPkModel",
+ async (project, { dispatch, getState }) => {
+ const initialPkModel = {
+ name: "new",
+ project: project.id,
+ mappings: [],
+ };
+ let pkModel = await api.post("/api/dosed_pharmacokinetic/", getState().login.csrf, initialPkModel);
+ dispatch(fetchVariablesByPkModel(pkModel.id));
+ dispatch(fetchUnitsByPkModel(pkModel.id));
+ dispatch(fetchPkModelSimulateById(pkModel.id));
+ return pkModel;
+ }
+);
+
+export const updatePkModel = createAsyncThunk(
+ "pkModels/updatePkModel",
+ async (pkModel, { dispatch, getState }) => {
+ let newPkModel = await api.put(
+ `/api/dosed_pharmacokinetic/${pkModel.id}/`, getState().login.csrf,
+ pkModel
+ );
+ // an update could create new variables
+ dispatch(fetchVariablesByPkModel(newPkModel.id));
+ dispatch(fetchUnitsByPkModel(newPkModel.id));
+ dispatch(fetchPkModelSimulateById(newPkModel.id));
+ //const simulateData = {
+ // outputs: pkModel.outputs.filter(x => x.default_value).map(x => x.name),
+ // initial_conditions: pkModel.outputs.reduce((o, x) => ({...o, x.name: x.default_value}), {}),
+ // variables: pkModel.variables.reduce((o, x) => ({...o, x.name: x.default_value}), {}),
+ //}
+ //const result = await api.post(
+ // `/api/dosed_pharmacokinetic/${pkModel.id}/simulate`, simulateData
+ //)
+ //return { ...newPkModel, simulate: result }
+ return newPkModel;
+ }
+);
+
+export const pkModelsSlice = createSlice({
+ name: "pkModels",
+ initialState,
+ reducers: {
+ togglePkModel(state, action) {
+ let pkModel = state.entities[action.payload.id];
+ pkModel.chosen = !pkModel.chosen;
+ },
+ setSelectPkModel(state, action) {
+ let pkModel = state.entities[action.payload.id];
+ pkModel.selected = action.payload.select;
+ },
+ addPkModels: pkModelsAdapter.upsertMany,
+ },
+ extraReducers: {
+
+ [fetchPkModels.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchPkModels.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchPkModels.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ pkModelsAdapter.setAll(state, action.payload);
+ },
+ [deletePkModel.fulfilled]: pkModelsAdapter.removeOne,
+ [fetchPkModelById.fulfilled]: pkModelsAdapter.upsertOne,
+ [fetchPkModelSimulateById.pending]: (state, action) => {
+ if (state.ids.includes(action.meta.arg)) {
+ state.entities[action.meta.arg].simulate = {
+ status: "loading",
+ };
+ }
+ },
+ [fetchPkModelSimulateById.fulfilled]: (state, action) => {
+ if (state.ids.includes(action.meta.arg)) {
+ state.entities[action.meta.arg].simulate = {
+ ...action.payload,
+ status: "succeeded",
+ };
+ }
+ },
+ [fetchPkModelSimulateById.rejected]: (state, action) => {
+ if (state.ids.includes(action.meta.arg)) {
+ state.entities[action.meta.arg].simulate = {
+ status: "failed",
+ };
+ }
+ },
+ [addNewPkModel.rejected]: (state, action) =>
+ console.log(action.error.message),
+ [addNewPkModel.fulfilled]: pkModelsAdapter.addOne,
+ [updatePkModel.fulfilled]: pkModelsAdapter.upsertOne,
+ [setPkVariablesByInference.fulfilled]: pkModelsAdapter.upsertOne,
+ },
+});
+
+export const { togglePkModel, setSelectPkModel, addPkModels } = pkModelsSlice.actions;
+
+export default pkModelsSlice.reducer;
+
+export const {
+ selectAll: selectAllPkModels,
+ selectById: selectPkModelById,
+ selectIds: selectPkModelIds,
+} = pkModelsAdapter.getSelectors((state) => state.pkModels);
+
+export const selectChosenPkModels = (state) =>
+ selectAllPkModels(state).filter((pkModel) => pkModel.chosen);
+
+export const selectWritablePkModels = (state) =>
+ selectAllPkModels(state).filter((pkModel) => !pkModel.read_only);
+
+export const selectWritablePkModelIds = (state) =>
+ selectAllPkModels(state).filter((pkModel) => !pkModel.read_only).map(pkModel => pkModel.id);
+
+export const selectReadOnlyPkModels = (state) =>
+ selectAllPkModels(state).filter((pkModel) => pkModel.read_only);
+
diff --git a/frontend/src/features/projects/ImportMonolixDialog.js b/frontend/src/features/projects/ImportMonolixDialog.js
new file mode 100644
index 00000000..fd132ab8
--- /dev/null
+++ b/frontend/src/features/projects/ImportMonolixDialog.js
@@ -0,0 +1,312 @@
+import React, { useEffect, useState } from "react";
+import { useDispatch, useSelector } from "react-redux";
+import Button from "@mui/material/Button";
+import Card from "@mui/material/Card";
+import CardContent from "@mui/material/CardContent";
+import CardMedia from "@mui/material/CardMedia";
+import CardActions from "@mui/material/CardActions";
+import Divider from "@mui/material/Divider";
+import TextField from "@mui/material/TextField";
+import { useForm, useFieldArray } from "react-hook-form";
+import Dialog from '@mui/material/Dialog';
+import DialogContent from '@mui/material/DialogContent';
+import Box from "@mui/material/Box";
+import Stack from "@mui/material/Stack";
+import makeStyles from '@mui/styles/makeStyles';
+import { selectAllInferences } from "../inference/inferenceSlice";
+import Table from '@mui/material/Table';
+import TableCell from '@mui/material/TableCell';
+import Tooltip from "@mui/material/Tooltip";
+import TableContainer from '@mui/material/TableContainer';
+import TableBody from '@mui/material/TableBody';
+import TableRow from '@mui/material/TableRow';
+import TableHead from '@mui/material/TableHead';
+
+import Typography from "@mui/material/Typography";
+import DialogActions from "@mui/material/DialogActions";
+
+import LinearProgressWithLabel from '../menu/LinearProgressWithLabel'
+import { FormSelectField } from "../forms/FormComponents";
+import { CardActionArea } from "@mui/material";
+import { importMonolix, importMonolixStatus, importMonolixErrors } from "./projectsSlice";
+
+const useStyles = makeStyles((theme) => ({
+ fileCard: {
+ marginTop: theme.spacing(1),
+ marginBottom: theme.spacing(1),
+ paddingTop: theme.spacing(1),
+ paddingBottom: theme.spacing(1),
+ },
+ fileCardContent: {
+ display: "flex",
+ flexDirection: "column",
+ },
+ paper: {
+ padding: theme.spacing(2),
+ textAlign: "left",
+ },
+ controlsRoot: {
+ display: "flex",
+ alignItems: "center",
+ },
+ controls: {
+ margin: theme.spacing(1),
+ minWidth: 120,
+ },
+ dialogPaper: {
+ "& > *": {
+ margin: theme.spacing(1),
+ },
+ },
+ content: {
+ marginTop: theme.spacing(2),
+ maxHeight: 100,
+ overflow: "auto",
+ }
+}));
+
+function FileCard({ index, file, control, api_errors, errors, clearErrors }) {
+ const classes = useStyles();
+ const [content, setContent] = useState(null);
+ const filename = file.file.name;
+ const filetype = file.type;
+
+ useEffect(() => {
+ const reader = new FileReader();
+ reader.onload = function() {
+ setContent(reader.result);
+ };
+ reader.onerror = function() {
+ setContent("Error: could not read file");
+ };
+ reader.readAsText(file.file);
+ }, [file.file])
+
+ const current_type = file.monolix_type;
+ let error = null;
+ if (api_errors && api_errors[current_type]) {
+ error = api_errors[current_type]
+ }
+
+ console.log('errors', errors, 'index', index)
+
+ const handleOnChange = (e) => {
+ console.log('e', e)
+ clearErrors(`files[${index}].monolix_type`);
+ if (e.target.value === 'project_mlxtran') {
+ clearErrors('project_mlxtran');
+ }
+ if (e.target.value === 'model_txt') {
+ clearErrors('model_txt');
+ }
+ if (e.target.value === 'data_csv') {
+ clearErrors('data_csv');
+ }
+ return e;
+ }
+
+ return (
+
+
+
+
+ {file.file.name}
+
+
+
+ {content}
+
+
+ }
+
+ {error &&
+ {error.replace(/\n/g, "
+ }
+
+
+
+
+
+
+ );
+}
+
+
+
+export default function ImportMonolixDialog({ project, onClose, open }) {
+ const classes = useStyles();
+ const dispatch = useDispatch();
+ const [fileList, setFileList] = useState(null);
+ const uploadStatus = useSelector(state => importMonolixStatus(state, project));
+ const uploadErrors = useSelector(state => importMonolixErrors(state, project));
+ const { handleSubmit, control, register, reset, setError, formState: { errors }, clearErrors, watch } = useForm();
+ const { fields, append, prepend, remove, swap, move, insert, replace } = useFieldArray({
+ control,
+ name: "files",
+ });
+ console.log('errors', errors);
+
+ const handleFileChange = (e) => {
+ const fileList = e.target.files;
+ const files = fileList ? [...fileList] : [];
+ const files_with_type = files.map(file => {
+ if (file.name.endsWith('.mlxtran')) {
+ return { file, monolix_type: 'project_mlxtran'}
+ } else if (file.name.endsWith('.csv')) {
+ return { file, monolix_type: 'data_csv'}
+ } else if (file.name.endsWith('.txt')) {
+ return { file, monolix_type: 'model_txt' }
+ } else {
+ return { file, monolix_type: ''}
+ }
+ });
+ reset({ files: files_with_type });
+ };
+
+ useEffect(() => {
+ validateFiles(fields);
+ }, [JSON.stringify(fields)]);
+
+ const validateFiles = (files) => {
+ console.log('validateFiles', files)
+ if (!files) {
+ return;
+ }
+ const project_indices = files.map(
+ (file, index) => ({index, type: file.monolix_type})
+ ).filter(({index, type}) => type === 'project_mlxtran')
+ .map(({index, type}) => index);
+ const data_indices = files.map(
+ (file, index) => ({index, type: file.monolix_type})
+ ).filter(({index, type}) => type === 'data_csv')
+ .map(({index, type}) => index);
+ const model_indices = files.map(
+ (file, index) => ({index, type: file.monolix_type})
+ ).filter(({index, type}) => type === 'model_txt')
+ .map(({index, type}) => index);
+
+ let errored = false;
+ if (project_indices.length !== 1) {
+ if (project_indices.length === 0) {
+ setError(`project_mlxtran`, { type: 'custom', message: 'A project file is required' });
+ }
+ for (const index of project_indices) {
+ setError(`files[ ${index}].monolix_type`, { type: 'custom', message: 'Only one project file is allowed' });
+ }
+ errored = true;
+ }
+ if (data_indices.length !== 1) {
+ if (data_indices.length === 0) {
+ setError(`data_csv`, { type: 'custom', message: 'A data file is required' });
+ }
+ for (const index of data_indices) {
+ setError(`files[${index}].monolix_type`, { type: 'custom', message: 'Only one data file is allowed' });
+ }
+ errored = true;
+ }
+ console.log('model_indices', model_indices)
+ if (model_indices.length !== 1) {
+ if (model_indices.length === 0) {
+ setError(`model_txt`, { type: 'custom', message: 'A model file is required' });
+ }
+ console.log('XXmodel_indices', model_indices)
+ for (const index of model_indices) {
+ setError(`files[${index}].monolix_type`, { type: 'custom', message: 'Only one model file is allowed' });
+ }
+ errored = true;
+ }
+ if (!errored) {
+ clearErrors();
+ }
+ return errored;
+ };
+
+ const onSubmit = (files) => {
+ console.log('uploading files', files.files)
+ const errored = validateFiles(files.files);
+ if (errored) {
+ return;
+ }
+ const data = {
+ id: project.id,
+ project_mlxtran: files.files.filter(file => file.monolix_type === 'project_mlxtran')[0].file,
+ model_txt: files.files.filter(file => file.monolix_type === 'model_txt')[0].file,
+ data_csv: files.files.filter(file => file.monolix_type === 'data_csv')[0].file,
+ }
+
+ dispatch(importMonolix(data));
+ };
+
+ const files = fileList ? [...fileList] : [];
+
+ const handleClose = () => {
+ reset({ files: [] });
+ onClose();
+ };
+
+
+ let uploadButtonColor = 'primary'
+ if (uploadStatus === 'loading') {
+ uploadButtonColor = 'secondary'
+ } else if (uploadStatus === 'success') {
+ uploadButtonColor = 'succeeded'
+ } else if (uploadStatus === 'failed') {
+ uploadButtonColor = 'error'
+ }
+
+ return (
+
+ );
+}
diff --git a/frontend/src/features/projects/Project.js b/frontend/src/features/projects/Project.js
new file mode 100644
index 00000000..78d69810
--- /dev/null
+++ b/frontend/src/features/projects/Project.js
@@ -0,0 +1,103 @@
+import React, { useEffect } from "react";
+import {
+ Switch,
+ Route,
+ useParams,
+ Link,
+ matchPath,
+ useRouteMatch,
+ Redirect,
+ useLocation,
+ useHistory,
+} from "react-router-dom";
+
+import { useSelector, useDispatch } from "react-redux";
+import Button from "@mui/material/Button";
+import Paper from "@mui/material/Paper";
+import { useForm } from "react-hook-form";
+import makeStyles from '@mui/styles/makeStyles';
+import List from "@mui/material/List";
+import CircularProgress from "@mui/material/CircularProgress";
+import ListItem from "@mui/material/ListItem";
+
+import Inferences from "../inference/Inferences";
+import Inference from "../inference/Inference";
+import Modelling from "../modelling/Modelling";
+import Header from "../modelling/Header";
+import Footer from "../modelling/Footer";
+
+import {
+ FormTextField,
+ FormMultiSelectField,
+ FormCheckboxField,
+} from "../forms/FormComponents";
+import { selectAllUsers } from "../projects/usersSlice.js";
+
+import {
+ selectProjectById,
+ updateProject,
+ chooseProject,
+ deleteProject,
+ userHasReadOnlyAccess,
+} from "../projects/projectsSlice.js";
+
+import { fetchDatasets } from "../datasets/datasetsSlice.js";
+
+import { fetchUnits} from "../projects/unitsSlice.js";
+
+import { fetchPkModels } from "../pkModels/pkModelsSlice.js";
+
+import { fetchPdModels } from "../pdModels/pdModelsSlice.js";
+
+import { fetchBasePkModels } from "../pkModels/basePkModelsSlice.js";
+
+import { fetchProtocols } from "../protocols/protocolsSlice.js";
+
+import { fetchVariables } from "../variables/variablesSlice.js";
+
+import { fetchInferences } from "../inference/inferenceSlice.js";
+
+import { fetchChains } from "../inference/chainSlice.js";
+import { clearSelectItem } from "../modelling/modellingSlice";
+
+const useStyles = makeStyles((theme) => ({
+}));
+
+
+export default function Project() {
+ let { id } = useParams();
+ let { path, url } = useRouteMatch();
+ const project = useSelector((state) => selectProjectById(state, id));
+ const classes = useStyles();
+ const dispatch = useDispatch();
+
+ useEffect(() => {
+ dispatch(fetchDatasets(id));
+ dispatch(fetchPkModels(id));
+ dispatch(fetchPdModels(id));
+ dispatch(fetchBasePkModels(id));
+ dispatch(fetchVariables(id));
+ dispatch(fetchProtocols(id));
+ dispatch(fetchUnits(id));
+ dispatch(fetchInferences(id));
+ dispatch(clearSelectItem());
+ }, [id]);
+
+ if (!project) {
+ return (
+
+
+
+
+
+
+
+
+
+ );
+}
diff --git a/frontend/src/features/projects/ProjectDetail.js b/frontend/src/features/projects/ProjectDetail.js
new file mode 100644
index 00000000..c482b3ce
--- /dev/null
+++ b/frontend/src/features/projects/ProjectDetail.js
@@ -0,0 +1,134 @@
+import React, { useEffect, useState } from "react";
+import { useSelector, useDispatch } from "react-redux";
+import Stack from "@mui/material/Stack";
+import Paper from "@mui/material/Paper";
+import { useForm } from "react-hook-form";
+import List from "@mui/material/List";
+import ListItem from "@mui/material/ListItem";
+
+import Header from "../modelling/Header";
+import Footer from "../modelling/Footer";
+import ImportMonolixDialog from "./ImportMonolixDialog";
+
+import {
+ FormTextField,
+ FormMultiSelectField,
+ FormCheckboxField,
+} from "../forms/FormComponents";
+import { selectAllUsers } from "../projects/usersSlice.js";
+
+import {
+ updateProject,
+ deleteProject,
+ userHasReadOnlyAccess,
+} from "../projects/projectsSlice.js";
+
+
+export default function ProjectDetail({ project }) {
+ const users = useSelector(selectAllUsers);
+ const userEntities = useSelector((state) => state.users.entities);
+ const dispatch = useDispatch();
+ const { control, handleSubmit, reset } = useForm();
+ const disableSave = useSelector(state => userHasReadOnlyAccess(state, project));
+ const user_options = users.map((user) => ({
+ key: user.username,
+ value: user.id,
+ }));
+
+ useEffect(() => {
+ reset(project);
+ }, [reset, project]);
+
+ const [openMonolixDialog, setOpenMonolixDialog] = useState(false);
+
+ const handleCloseMonolixDialog = (arg) => {
+ setOpenMonolixDialog(false)
+ }
+
+ const handleImportMonolix = () => {
+ setOpenMonolixDialog(true)
+ }
+
+ const handleDeleteProject = () => {
+ console.log('delete project', project)
+ dispatch(deleteProject(project.id));
+ };
+
+ const onSubmit = (values) => {
+ const users_in_project = values.user_access.map((ua) => ua.user);
+ const users_to_be_added = values.users.filter(u => !users_in_project.includes(u));
+ const users_to_be_removed = values.user_access.filter(u => !values.users.includes(u.user)).map(u => u.user);
+ let new_user_access = values.user_access.filter((ua) => !users_to_be_removed.includes(ua.user));
+ new_user_access.push(...users_to_be_added.map(u => ({user: u, read_only: true, project: project.id})));
+ values.user_access = new_user_access;
+ console.log("project detail submit", values);
+ dispatch(updateProject(values));
+ };
+ return (
+
+
+
+ )
+}
+
+
diff --git a/frontend/src/features/projects/Projects.js b/frontend/src/features/projects/Projects.js
new file mode 100644
index 00000000..ee67d0f7
--- /dev/null
+++ b/frontend/src/features/projects/Projects.js
@@ -0,0 +1,134 @@
+import React, { useEffect } from "react";
+import { useSelector } from "react-redux";
+import Paper from "@mui/material/Paper";
+import Grid from "@mui/material/Grid";
+import Table from '@mui/material/Table';
+import { useHistory } from "react-router-dom";
+import Typography from '@mui/material/Typography';
+import Container from '@mui/material/Container';
+import TableBody from '@mui/material/TableBody';
+import ProjectDetail from "../projects/ProjectDetail";
+import Tooltip from "@mui/material/Tooltip";
+import { useTheme } from "@mui/material/styles";
+import { useDispatch } from "react-redux";
+import TableCell from '@mui/material/TableCell';
+import SaveIcon from '@mui/icons-material/Save';
+import TableContainer from '@mui/material/TableContainer';
+import TableHead from '@mui/material/TableHead';
+import DeleteIcon from '@mui/icons-material/Delete';
+import TableRow from '@mui/material/TableRow';
+
+import AddIcon from "@mui/icons-material/Add";
+
+import IconButton from "@mui/material/IconButton";
+import makeStyles from '@mui/styles/makeStyles';
+
+
+
+
+
+import {
+ selectMyProjects,
+ selectChosenProject,
+ addNewProject,
+ deleteProject,
+} from "./projectsSlice.js";
+
+const useStyles = makeStyles((theme) => ({
+ container: {
+ },
+ paper: {
+ padding: theme.spacing(2),
+ textAlign: "left",
+ },
+ controlsRoot: {
+ display: "flex",
+ alignItems: "center",
+ },
+ controls: {
+ margin: theme.spacing(1),
+ },
+}));
+
+export default function Projects() {
+ const classes = useStyles();
+ const theme = useTheme();
+ const dispatch = useDispatch();
+ const history = useHistory();
+
+
+
+ const handleNewProject = () => {
+ dispatch(addNewProject());
+ };
+
+ const projects = useSelector(selectMyProjects);
+
+ const handleRowClick = (project) => {
+ history.push(`/${project.id}/`);
+ }
+
+ const handleDelete = (id) => (event) => {
+ event.stopPropagation()
+ dispatch(deleteProject(id));
+ }
+
+ const column_headings = [
+ {label: 'Name', help: 'Project Name'},
+ {label: 'Description', help: 'Description'},
+ {label: 'Actions', help: 'Click icon to perform actions'},
+ ]
+
+ return (
+
+
+ My Projects
+
+
+
+
+
+ {column_headings.map(heading => (
+
+
+
+ {heading.label}
+
+
+
+ ))
+ }
+
+
+
+ {projects.map((project) => (
+
+ handleRowClick(project)}>
+
+ {project.name}
+
+
+ {project.description}
+
+
+
+
+
+
+
+
+
+
+ ))}
+
+
+
+
+
+
+
+
+ );
+}
diff --git a/frontend/src/features/projects/projectsSlice.js b/frontend/src/features/projects/projectsSlice.js
new file mode 100644
index 00000000..c6b84bce
--- /dev/null
+++ b/frontend/src/features/projects/projectsSlice.js
@@ -0,0 +1,158 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+
+import { api } from "../../Api";
+import { selectCurrentUser } from '../login/loginSlice'
+import { fetchPdModelById } from "../pdModels/pdModelsSlice";
+import { fetchPkModelById } from "../pkModels/pkModelsSlice";
+import { fetchDatasetById } from "../datasets/datasetsSlice";
+
+const projectsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = projectsAdapter.getInitialState({
+ status: "idle",
+ selected: null,
+ error: null,
+ monolix_errors: null,
+ monolix_status: null,
+});
+
+export const fetchProjects = createAsyncThunk(
+ "projects/fetchProjects",
+ async (_, { getState }) => {
+ return await api.get(`/api/project/`, getState().login.csrf);
+ }
+);
+
+export const addNewProject = createAsyncThunk(
+ "projects/addNewProject",
+ async (_, { getState }) => {
+ const user = selectCurrentUser(getState())
+ console.log('user is ', user)
+ const initialProject = {
+ name: "new",
+ user_access: [
+ {user: user.id, read_only: false}
+ ],
+ };
+ console.log("addNewProject", initialProject);
+ return await api.post("/api/project/", getState().login.csrf, initialProject);
+ }
+);
+
+export const deleteProject = createAsyncThunk(
+ "projects/deleteProject",
+ async (projectId, { dispatch, getState }) => {
+ await api.delete(`/api/project/${projectId}`, getState().login.csrf);
+ return projectId;
+ }
+);
+
+export const updateProject = createAsyncThunk(
+ "projects/updateProject",
+ async (project, { getState }) => {
+ const csrf = getState().login.csrf;
+ const new_project = await api.put(`/api/project/${project.id}/`, csrf, project);
+ return new_project;
+ }
+);
+
+export const importMonolix = createAsyncThunk(
+ "projects/importMonolix",
+ async ({ id, project_mlxtran, model_txt, data_csv }, { rejectWithValue, dispatch, getState }) => {
+ try {
+ let response = await api.putMultiPart(`/api/project/${id}/monolix/`, getState().login.csrf, { project_mlxtran, model_txt, data_csv });
+ console.log('response is ', response)
+ dispatch(fetchPdModelById(response.pd_model));
+ dispatch(fetchPkModelById(response.pk_model));
+ dispatch(fetchDatasetById(response.data));
+ return response;
+ } catch (error) {
+ return rejectWithValue(error);
+ }
+ }
+);
+
+export const projectsSlice = createSlice({
+ name: "projects",
+ initialState,
+ reducers: {
+ chooseProject(state, action) {
+ console.log("choose project", action);
+ state.selected = action.payload.id;
+ },
+ },
+ extraReducers: {
+ [fetchProjects.pending]: (state, action) => {
+ console.log("pending");
+ state.status = "loading";
+ },
+ [fetchProjects.rejected]: (state, action) => {
+ console.log("rejected", action.error.message);
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchProjects.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ projectsAdapter.setAll(state, action.payload);
+ },
+ [deleteProject.fulfilled]: projectsAdapter.removeOne,
+ [addNewProject.fulfilled]: projectsAdapter.addOne,
+ [updateProject.fulfilled]: projectsAdapter.upsertOne,
+ [importMonolix.pending]: (state, action) => {
+ state.entities[action.meta.arg.id].monolix_status = "loading";
+ state.entities[action.meta.arg.id].monolix_errors = null;
+ },
+ [importMonolix.rejected]: (state, action) => {
+ state.entities[action.meta.arg.id].monolix_status = "failed";
+ state.entities[action.meta.arg.id].monolix_errors = action.payload;
+ },
+ [importMonolix.fulfilled]: (state, action) => {
+ state.entities[action.meta.arg.id].monolix_status = "succeeded";
+ state.entities[action.meta.arg.id].monolix_errors = null;
+ },
+
+ },
+});
+
+export const { chooseProject } = projectsSlice.actions;
+
+export default projectsSlice.reducer;
+
+export const selectChosenProject = (state) => {
+ if (!state.projects.selected) {
+ return null;
+ }
+ return state.projects.entities[state.projects.selected];
+};
+
+export const {
+ selectAll: selectAllProjects,
+ selectById: selectProjectById,
+ selectIds: selectProjectIds,
+} = projectsAdapter.getSelectors((state) => state.projects);
+
+export const selectMyProjects = (state) =>
+ selectAllProjects(state).filter((p) =>
+ p.users.includes(state.login.user.id)
+ );
+
+export const userHasReadOnlyAccess = (state, project) => {
+ const access = project.user_access.find(
+ (x) => x.user === state.login.user.id
+ );
+ return access.read_only;
+};
+
+export const importMonolixStatus = (state, project) => {
+ return state.projects.entities[project.id].monolix_status;
+}
+
+export const importMonolixErrors = (state, project) => {
+ return state.projects.entities[project.id].monolix_errors;
+}
\ No newline at end of file
diff --git a/frontend/src/features/projects/unitsSlice.js b/frontend/src/features/projects/unitsSlice.js
new file mode 100644
index 00000000..4709f320
--- /dev/null
+++ b/frontend/src/features/projects/unitsSlice.js
@@ -0,0 +1,87 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+
+const unitsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = unitsAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchUnits = createAsyncThunk(
+ "units/fetchUnits",
+ async (project, { getState }) => {
+ const response = await api.get(`/api/unit/`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const fetchUnitsByPdModel = createAsyncThunk(
+ "units/fetchUnitsByPdModel",
+ async (pd_model_id, { getState }) => {
+ const response = await api.get(`/api/unit/?pd_model_id=${pd_model_id}`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const fetchUnitsByPkModel = createAsyncThunk(
+ "units/fetchUnitsByPkModel",
+ async (pk_model_id, { getState }) => {
+ const response = await api.get(
+ `/api/unit/?dosed_pk_model_id=${pk_model_id}`, getState().login.csrf
+ );
+ return response;
+ }
+);
+
+export const addNewUnit = createAsyncThunk("units/addNewUnit", async (_, { getState}) => {
+ const initialUnit = {
+ name: "new",
+ };
+ const unit = await api.post("/api/unit/", getState().login.csrf, initialUnit);
+ return unit;
+});
+
+export const updateUnit = createAsyncThunk("units/updateUnit", async (unit, { getState }) => {
+ const response = await api.put(`/api/unit/${unit.id}/`, getState().login.csrf, unit);
+ return response;
+});
+
+export const unitsSlice = createSlice({
+ name: "units",
+ initialState,
+ reducers: {},
+ extraReducers: {
+ [fetchUnits.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchUnits.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchUnits.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ unitsAdapter.setAll(state, action.payload);
+ },
+ [fetchUnitsByPdModel.fulfilled]: unitsAdapter.upsertMany,
+ [fetchUnitsByPkModel.fulfilled]: unitsAdapter.upsertMany,
+ [addNewUnit.fulfilled]: unitsAdapter.addOne,
+ [updateUnit.fulfilled]: unitsAdapter.upsertOne,
+ },
+});
+
+// export const {} = unitsSlice.actions
+
+export default unitsSlice.reducer;
+
+export const {
+ selectAll: selectAllUnits,
+ selectById: selectUnitById,
+ selectIds: selectUnitIds,
+} = unitsAdapter.getSelectors((state) => state.units);
diff --git a/frontend/src/features/projects/usersSlice.js b/frontend/src/features/projects/usersSlice.js
new file mode 100644
index 00000000..b587acc3
--- /dev/null
+++ b/frontend/src/features/projects/usersSlice.js
@@ -0,0 +1,67 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+
+const usersAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = usersAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchUsers = createAsyncThunk("users/fetchUsers", async (_, { getState }) => {
+ const response = await api.get(`/api/user/`, getState().login.csrf);
+ return response;
+});
+
+export const addNewUser = createAsyncThunk("users/addNewUser", async (_, { getState }) => {
+ const initialUser = {
+ name: "new",
+ };
+ const response = await api.post("/api/user/", getState().login.csrf, initialUser);
+ return response;
+});
+
+export const updateUser = createAsyncThunk("users/updateUser", async (user, { getState }) => {
+ const response = await api.put(`/api/user/${user.id}/`, getState().login.csrf, user);
+ return response;
+});
+
+export const usersSlice = createSlice({
+ name: "users",
+ initialState,
+ reducers: {},
+ extraReducers: {
+ [fetchUsers.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchUsers.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchUsers.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ usersAdapter.setAll(state, action.payload);
+ },
+ [addNewUser.fulfilled]: usersAdapter.addOne,
+ [updateUser.fulfilled]: usersAdapter.upsertOne,
+ },
+});
+
+// export const { } = usersSlice.actions
+
+export default usersSlice.reducer;
+
+export const {
+ selectAll: selectAllUsers,
+ selectById: selectUserById,
+ selectIds: selectUserIds,
+} = usersAdapter.getSelectors((state) => state.users);
+
+export const selectChosenUsers = (state) =>
+ selectAllUsers(state).filter((user) => user.chosen);
diff --git a/frontend/src/features/protocols/DatasetProtocols.js b/frontend/src/features/protocols/DatasetProtocols.js
new file mode 100644
index 00000000..02d463d4
--- /dev/null
+++ b/frontend/src/features/protocols/DatasetProtocols.js
@@ -0,0 +1,36 @@
+import React from "react";
+import { useSelector, useDispatch } from "react-redux";
+
+import AccessibilityIcon from "@mui/icons-material/Accessibility";
+
+import ExpandableListItem from "../menu/ExpandableListItem";
+
+import {
+ addNewProtocol,
+} from "../protocols/protocolsSlice.js";
+
+
+import {
+ selectAllProtocols,
+ toggleProtocol,
+} from "../datasets/datasetsSlice.js";
+
+
+export default function DatasetProtocols({ project, disableSave }) {
+ const protocols = useSelector(selectAllProtocols);
+ const dispatch = useDispatch();
+ const handleClickItem = (item) => dispatch(toggleProtocol(item));
+ const handleNewItem = () => dispatch(addNewProtocol(project));
+
+ return (
+
+
+
+ );
+}
diff --git a/frontend/src/features/protocols/protocolsSlice.js b/frontend/src/features/protocols/protocolsSlice.js
new file mode 100644
index 00000000..24b74999
--- /dev/null
+++ b/frontend/src/features/protocols/protocolsSlice.js
@@ -0,0 +1,155 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+import { setSelected } from "../modelling/modellingSlice";
+import { fetchPkModelById } from "../pkModels/pkModelsSlice";
+
+const protocolsAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = protocolsAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchProtocols = createAsyncThunk(
+ "protocols/fetchProtocols",
+ async (project_id, { getState }) => {
+ const response = await api.get(`/api/protocol/?project_id=${project_id}`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const addNewProtocol = createAsyncThunk(
+ "protocols/addNewProtocol",
+ async (project, { dispatch, getState }) => {
+ const initialProtocol = {
+ name: "new",
+ dose_ids: [],
+ project: project.id,
+ };
+ let protocol = await api.post("/api/protocol/", getState().login.csrf, initialProtocol);
+ return protocol;
+ }
+);
+
+export const deleteProtocol = createAsyncThunk(
+ "protocols/deleteProtocol",
+ async (protocolId, { dispatch, getState }) => {
+ let { modelling } = getState()
+ if (modelling.selectedType === 'protocol' && modelling.selectedId === protocolId) {
+ await dispatch(setSelected({id: null, type: null}))
+ }
+ await api.delete(`/api/protocol/${protocolId}`, getState().login.csrf);
+ return protocolId;
+ }
+);
+
+export const updateProtocol = createAsyncThunk(
+ "protocols/updateProtocol",
+ async (protocol, { getState, dispatch }) => {
+ const csrf = getState().login.csrf
+ const dosePromises = protocol.doses.map((dose) => {
+ // add or update doses
+ const data = {
+ protocol: protocol.id,
+ ...dose,
+ };
+ if (dose.id) {
+ return api.put(`/api/dose/${dose.id}/`, csrf, data);
+ } else {
+ return api.post(`/api/dose/`, csrf, data);
+ }
+ });
+ const dose_ids = await Promise.all(dosePromises).then((doses) =>
+ doses.map((x) => x.id)
+ );
+
+ // delete removed doses
+ const toDelete = getState()
+ .protocols.entities[protocol.id].doses.map((x) => x.id)
+ .filter((x) => !dose_ids.includes(x));
+ await Promise.all(
+ toDelete.map((id) => {
+ return api.delete(`api/dose/${id}/`, csrf);
+ })
+ );
+
+ console.log("have dose_ids", dose_ids, toDelete);
+ const updatedProtocol = { ...protocol, dose_ids };
+ const newProtocol = await api.put(
+ `/api/protocol/${protocol.id}/`, csrf,
+ updatedProtocol
+ );
+ console.log("got new protocol", newProtocol);
+ for (const pkModelId of newProtocol.dosed_pk_models) {
+ console.log("fetching", pkModelId);
+ dispatch(fetchPkModelById(pkModelId));
+ }
+ return newProtocol;
+ }
+);
+
+export const protocolsSlice = createSlice({
+ name: "protocols",
+ initialState,
+ reducers: {
+ toggleProtocol(state, action) {
+ let protocol = state.entities[action.payload.id];
+ protocol.chosen = !protocol.chosen;
+ },
+ setSelectProtocol(state, action) {
+ let protocol = state.entities[action.payload.id];
+ protocol.selected = action.payload.select;
+ },
+ },
+ extraReducers: {
+ [fetchProtocols.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchProtocols.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchProtocols.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ protocolsAdapter.setAll(state, action.payload);
+ },
+ [deleteProtocol.fulfilled]: protocolsAdapter.removeOne,
+ [addNewProtocol.fulfilled]: protocolsAdapter.addOne,
+ [addNewProtocol.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [updateProtocol.fulfilled]: protocolsAdapter.upsertOne,
+ [updateProtocol.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ },
+});
+
+export const { toggleProtocol, setSelectProtocol } = protocolsSlice.actions;
+
+export default protocolsSlice.reducer;
+
+export const {
+ selectAll: selectAllProtocols,
+ selectById: selectProtocolById,
+ selectIds: selectProtocolIds,
+} = protocolsAdapter.getSelectors((state) => state.protocols);
+
+export const selectChosenProtocols = (state) =>
+ selectAllProtocols(state).filter((protocol) => protocol.chosen);
+
+export const selectDatasetProtocols = (state, dataset) =>
+ selectAllProtocols(state).filter(
+ (protocol) => protocol.dataset === dataset.id
+ );
+
+export const selectWritableProtocols = (state, dataset) =>
+ selectAllProtocols(state).filter((protocol) => !protocol.read_only);
diff --git a/frontend/src/features/variables/OutputSubform.js b/frontend/src/features/variables/OutputSubform.js
new file mode 100644
index 00000000..24de8338
--- /dev/null
+++ b/frontend/src/features/variables/OutputSubform.js
@@ -0,0 +1,102 @@
+import React, { useEffect } from "react";
+import { useSelector } from "react-redux";
+import {
+ FormCheckboxField,
+ FormTextField,
+ FormSelectField,
+} from "../forms/FormComponents";
+import { useForm, useFormState } from "react-hook-form";
+import SaveIcon from "@mui/icons-material/Save";
+import IconButton from "@mui/material/IconButton";
+import { useDispatch } from "react-redux";
+import { selectUnitById } from "../projects/unitsSlice";
+import { selectVariableById, updateVariable } from "./variablesSlice";
+import Stack from "@mui/material/Stack";
+
+export default function OutputSubform({ variable_id, disableSave }) {
+ const dispatch = useDispatch();
+ let variable = useSelector((state) => selectVariableById(state, variable_id));
+ if (!variable) {
+ variable = {
+ display: 0,
+ default_value: 0,
+ lower_bound: -1,
+ upper_bound: 1,
+ unit: 1,
+ color: 0,
+ axis: false,
+ };
+ }
+ const { control, handleSubmit, reset } = useForm({
+ defaultValues: {
+ id: variable.id,
+ display: variable.display,
+ color: variable.color,
+ unit: variable.unit,
+ axis: variable.axis,
+ },
+ });
+ const variableStringify = JSON.stringify(variable)
+
+ useEffect(() => {
+ reset(variable);
+ }, [variableStringify]);
+
+ const unit_id = variable ? variable.unit : 1;
+ let unit = useSelector((state) => selectUnitById(state, unit_id));
+ if (!unit) {
+ unit = {
+ symbol: "X",
+ compatible_units: [],
+ };
+ }
+ const unitOptions = unit.compatible_units.map((u) => {
+ return { key: u.symbol, value: u.id };
+ });
+ const label = `${variable.name}`;
+
+ const onSubmit = (values) => {
+ dispatch(updateVariable(values));
+ };
+
+ const { isDirty } = useFormState({ control });
+
+ const axisOptions = [
+ { value: false, key: "LHS" },
+ { value: true, key: "RHS" },
+ ];
+
+ return (
+
+
+
+
+ )}
+
+ );
+}
diff --git a/frontend/src/features/variables/VariableSubform.js b/frontend/src/features/variables/VariableSubform.js
new file mode 100644
index 00000000..6ec32503
--- /dev/null
+++ b/frontend/src/features/variables/VariableSubform.js
@@ -0,0 +1,136 @@
+import React, { useEffect } from "react";
+import { useSelector } from "react-redux";
+import { FormSliderField, FormTextField, FormCheckboxField } from "../forms/FormComponents";
+import Box from "@mui/material/Box";
+import Grid from "@mui/material/Grid";
+import { useForm, useFormState } from "react-hook-form";
+import SaveIcon from "@mui/icons-material/Save";
+import { useDispatch } from "react-redux";
+import IconButton from "@mui/material/IconButton";
+import { selectUnitById } from "../projects/unitsSlice";
+import { selectVariableById, updateVariable } from "./variablesSlice";
+
+export default function VariableSubform({ variable_id, disableSave }) {
+ const dispatch = useDispatch();
+ let variable = useSelector((state) => selectVariableById(state, variable_id));
+ if (!variable) {
+ variable = {
+ default_value: 0,
+ lower_bound: -1,
+ upper_bound: 1,
+ unit: 0,
+ };
+ }
+ const { control, handleSubmit, getValues, reset } = useForm({
+ defaultValues: {
+ id: variable.id,
+ default_value: variable.default_value,
+ lower_bound: variable.lower_bound,
+ upper_bound: variable.upper_bound,
+ is_log: variable.is_log,
+ },
+ });
+ const variableStringify = JSON.stringify(variable)
+
+ useEffect(() => {
+ console.log('useEffect variable subform', variable)
+ reset(variable);
+ }, [variableStringify]);
+
+ const unit_id = variable ? variable.unit : 1;
+ let unit = useSelector((state) => selectUnitById(state, unit_id));
+ if (!unit) {
+ unit = {
+ symbol: "",
+ };
+ }
+ const label = variable.name === 'size' ?
+ `volume [${unit.symbol}]` :
+ `${variable.name} [${unit.symbol}]`
+ ;
+ let truncatedLabel = label;
+ const maxLength = 15;
+ if (label.length > maxLength) {
+ truncatedLabel = label.slice(0, maxLength - 2) + "...";
+ }
+
+ const onSubmit = (values) => {
+ dispatch(updateVariable(values));
+ };
+
+ const { isDirty } = useFormState({ control });
+ const current_lower_bound = getValues("lower_bound");
+ const current_upper_bound = getValues("upper_bound");
+ const current_is_log = getValues("is_log");
+
+ return (
+
+
+
+
+
+
+
+ {isDirty && (
+
+
+ )}
+
+
+
+
+
+
+
+
+
+ );
+}
diff --git a/frontend/src/features/variables/variablesSlice.js b/frontend/src/features/variables/variablesSlice.js
new file mode 100644
index 00000000..22a75654
--- /dev/null
+++ b/frontend/src/features/variables/variablesSlice.js
@@ -0,0 +1,155 @@
+import {
+ createSlice,
+ createEntityAdapter,
+ createAsyncThunk,
+} from "@reduxjs/toolkit";
+import { api } from "../../Api";
+import { fetchPdModelById } from "../pdModels/pdModelsSlice";
+import { fetchPkModelById } from "../pkModels/pkModelsSlice";
+
+const variablesAdapter = createEntityAdapter({
+ sortComparer: (a, b) => b.id < a.id,
+});
+
+const initialState = variablesAdapter.getInitialState({
+ status: "idle",
+ error: null,
+});
+
+export const fetchVariables = createAsyncThunk(
+ "variables/fetchVariables",
+ async (project_id, { getState }) => {
+ console.log("called fetchVariables");
+ const response = await api.get(`/api/variable/?project_id=${project_id}`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const fetchVariableById = createAsyncThunk(
+ "variables/fetchVariableById",
+ async (variable_id, { getState }) => {
+ const response = await api.get(`/api/variable/${variable_id}/`, getState().login.csrf);
+ return response;
+ }
+);
+
+export const fetchVariablesByPdModel = createAsyncThunk(
+ "variables/fetchVariablesByPdModel",
+ async (pd_model_id, { getState }) => {
+ const response = await api.get(`/api/variable/?pd_model_id=${pd_model_id}`, getState().login.csrf);
+ const responseIds = response.map(v => v.id)
+ const state = getState()
+ const existingVariables = selectVariablesByPdModel(state, pd_model_id)
+ const deletedVariables = existingVariables.filter(v => responseIds.indexOf(v.id) === -1)
+ return {
+ variables: response,
+ deletedVariables
+ };
+ }
+);
+
+
+export const fetchVariablesByPkModel = createAsyncThunk(
+ "variables/fetchVariablesByPkModel",
+ async (pk_model_id, { getState }) => {
+ const response = await api.get(
+ `/api/variable/?dosed_pk_model_id=${pk_model_id}`, getState().login.csrf
+ );
+ const responseIds = response.map(v => v.id)
+ const state = getState()
+ const existingVariables = selectVariablesByDosedPkModel(state, pk_model_id)
+ const deletedVariables = existingVariables.filter(v => responseIds.indexOf(v.id) === -1)
+ return {
+ variables: response,
+ deletedVariables
+ };
+ }
+);
+
+export const addNewVariable = createAsyncThunk(
+ "variables/addNewVariable",
+ async (_, { getState }) => {
+ const initialVariable = {
+ name: "new",
+ };
+ const variable = await api.post("/api/variable/", getState().login.csrf, initialVariable);
+ return variable;
+ }
+);
+
+export const updateVariable = createAsyncThunk(
+ "variables/updateVariable",
+ async (variable, { dispatch, getState }) => {
+ const response = await api.patch(`/api/variable/${variable.id}/`, getState().login.csrf, variable);
+ if (response.pd_model) {
+ dispatch(fetchPdModelById(response.pd_model));
+ }
+ if (response.dosed_pk_model) {
+ dispatch(fetchPkModelById(response.dosed_pk_model));
+ }
+ return response;
+ }
+);
+
+export const variablesSlice = createSlice({
+ name: "variables",
+ initialState,
+ reducers: {
+ addVariables: variablesAdapter.upsertMany,
+ },
+ extraReducers: {
+ [fetchVariables.pending]: (state, action) => {
+ state.status = "loading";
+ },
+ [fetchVariables.rejected]: (state, action) => {
+ state.status = "failed";
+ state.error = action.error.message;
+ },
+ [fetchVariables.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ variablesAdapter.setAll(state, action.payload);
+ },
+ [fetchVariableById.fulfilled]: variablesAdapter.upsertOne,
+ [fetchVariablesByPdModel.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ if (action.payload.deletedVariables.length > 0) {
+ variablesAdapter.removeMany(state, action.payload.deletedVariables.map(v => v.id))
+ }
+ variablesAdapter.upsertMany(state, action.payload.variables);
+ },
+ [fetchVariablesByPkModel.fulfilled]: (state, action) => {
+ state.status = "succeeded";
+ if (action.payload.deletedVariables.length > 0) {
+ variablesAdapter.removeMany(state, action.payload.deletedVariables.map(v => v.id))
+ }
+ variablesAdapter.upsertMany(state, action.payload.variables);
+ },
+ [addNewVariable.fulfilled]: variablesAdapter.addOne,
+ [updateVariable.fulfilled]: variablesAdapter.upsertOne,
+ },
+});
+
+export const { addVariables } = variablesSlice.actions;
+
+export default variablesSlice.reducer;
+
+export const {
+ selectAll: selectAllVariables,
+ selectById: selectVariableById,
+ selectIds: selectVariableIds,
+} = variablesAdapter.getSelectors((state) => state.variables);
+
+export const selectVariablesByPdModel = (state, model_id, model_type) =>
+ selectAllVariables(state).filter(
+ (variable) => variable.pd_model === model_id
+ );
+
+export const selectVariablesByDosedPkModel = (state, model_id, model_type) =>
+ selectAllVariables(state).filter(
+ (variable) => variable.dosed_pk_model === model_id
+ );
+
+export const selectVariablesByPkpdModel = (state, model_id, model_type) =>
+ selectAllVariables(state).filter(
+ (variable) => variable.pkpd_model === model_id
+ );
diff --git a/frontend/src/index.css b/frontend/src/index.css
new file mode 100644
index 00000000..4a1df4db
--- /dev/null
+++ b/frontend/src/index.css
@@ -0,0 +1,13 @@
+body {
+ margin: 0;
+ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen",
+ "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue",
+ sans-serif;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+}
+
+code {
+ font-family: source-code-pro, Menlo, Monaco, Consolas, "Courier New",
+ monospace;
+}
diff --git a/frontend/src/index.js b/frontend/src/index.js
new file mode 100644
index 00000000..0c56bba8
--- /dev/null
+++ b/frontend/src/index.js
@@ -0,0 +1,25 @@
+import React from "react";
+import ReactDOM from "react-dom";
+import "./index.css";
+import App from "./App";
+import reportWebVitals from "./reportWebVitals";
+import { BrowserRouter as Router } from "react-router-dom";
+import store from "./app/store";
+import { Provider } from "react-redux";
+
+ReactDOM.render(
+
+
+
+
+ ,
+
+ ,
+ document.getElementById("root")
+);
+
+// If you want to start measuring performance in your app, pass a function
+// to log results (for example: reportWebVitals(console.log))
+// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
+reportWebVitals();
diff --git a/frontend/src/logo.svg b/frontend/src/logo.svg
new file mode 100644
index 00000000..465cf440
--- /dev/null
+++ b/frontend/src/logo.svg
@@ -0,0 +1,79 @@
+
+
+
diff --git a/frontend/src/logo_pkpdapp_with_text.svg b/frontend/src/logo_pkpdapp_with_text.svg
new file mode 100644
index 00000000..1b524776
--- /dev/null
+++ b/frontend/src/logo_pkpdapp_with_text.svg
@@ -0,0 +1 @@
+PKPD APP
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ka
+ Agi
+
+
+
+
+
+
+
+
+
+
+
+ k10
+ A1
+
+
+
+
+
+
+
+
+
+
diff --git a/pkpdapp/media/model/2_comp_PK_model_simple.xml b/pkpdapp/media/model/2_comp_PK_model_simple.xml
new file mode 100644
index 00000000..66649691
--- /dev/null
+++ b/pkpdapp/media/model/2_comp_PK_model_simple.xml
@@ -0,0 +1,175 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ka
+ Agi
+
+
+
+
+
+
+
+
+
+
+
+
+
+ k12
+ A1
+
+
+
+
+
+
+
+
+
+
+
+
+
+ k21
+ A2
+
+
+
+
+
+
+
+
+
+
+
+ k10
+ A1
+
+
+
+
+
+
+
+
+
+
diff --git a/pkpdapp/media/model/3_comp_PK_model.xml b/pkpdapp/media/model/3_comp_PK_model.xml
new file mode 100644
index 00000000..dd7265af
--- /dev/null
+++ b/pkpdapp/media/model/3_comp_PK_model.xml
@@ -0,0 +1,220 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ka
+ Agi
+
+
+
+
+
+
+
+
+
+
+
+
+
+ k12
+ A1
+
+
+
+
+
+
+
+
+
+
+
+
+
+ k21
+ A2
+
+
+
+
+
+
+
+
+
+
+
+ k10
+ A1
+
+
+
+
+
+
+
+
+
+
+
+
+
+ k13
+ A1
+
+
+
+
+
+
+
+
+
+
+
+
+
+ k21
+ A3
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pkpdapp/media/model/tumour_growth_without_treatment.xml b/pkpdapp/media/model/tumour_growth_without_treatment.xml
new file mode 100644
index 00000000..9d2c135c
--- /dev/null
+++ b/pkpdapp/media/model/tumour_growth_without_treatment.xml
@@ -0,0 +1,47 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lambda
+ critical_volume
+ tumour_volume
+
+
+ tumour_volume
+ critical_volume
+
+
+
+
+
+
+
diff --git a/pkpdapp/pkpdapp/__init__.py b/pkpdapp/pkpdapp/__init__.py
new file mode 100644
index 00000000..b1c69e7a
--- /dev/null
+++ b/pkpdapp/pkpdapp/__init__.py
@@ -0,0 +1,11 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from .celery import app as celery_app
+
+default_app_config = 'pkpdapp.apps.PkpdAppConfig'
+
+__all__ = ('celery_app', 'default_app_config')
diff --git a/pkpdapp/pkpdapp/admin.py b/pkpdapp/pkpdapp/admin.py
new file mode 100644
index 00000000..7ce08081
--- /dev/null
+++ b/pkpdapp/pkpdapp/admin.py
@@ -0,0 +1,16 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.contrib import admin
+from django.apps import apps
+
+models = apps.get_models()
+
+for model in models:
+ try:
+ admin.site.register(model)
+ except admin.sites.AlreadyRegistered:
+ pass
diff --git a/pkpdapp/pkpdapp/api/__init__.py b/pkpdapp/pkpdapp/api/__init__.py
new file mode 100644
index 00000000..1b41d03c
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/__init__.py
@@ -0,0 +1,21 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+# flake8: noqa F401
+
+from .views import (
+ DatasetView, UserView, ProjectView, CompoundView,
+ PharmacokineticView, CombinedModelView,
+ PharmacodynamicView, DoseView,
+ ProtocolView, SimulateCombinedView, SimulatePdView,
+ UnitView, BiomarkerTypeView, VariableView, SubjectView,
+ ProjectAccessView, NcaView, AuceView,
+ InferenceView, InferenceChainView,
+ AlgorithmView,
+ StopInferenceView,
+ LogLikelihoodView, InferenceWizardView,
+ login_view, logout_view, get_csrf, SessionView, WhoAmIView,
+ SimulationViewSet,
+)
diff --git a/pkpdapp/pkpdapp/api/serializers/__init__.py b/pkpdapp/pkpdapp/api/serializers/__init__.py
new file mode 100644
index 00000000..1b540956
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/__init__.py
@@ -0,0 +1,50 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+# flake8: noqa F401
+
+
+from .polymorphicserializer import PolymorphicSerializer
+
+from .validators import (
+ ValidSbml, ValidMmt
+)
+from .monolix import MonolixSerializer
+from .auce import AuceSerializer
+from .biomarker_type import BiomarkerTypeSerializer
+from .dose import DoseSerializer
+from .efficacy_experiment import EfficacySerializer
+from .compound import CompoundSerializer
+from .models import (
+ PharmacokineticSerializer,
+ CombinedModelSerializer,
+ PharmacodynamicSerializer,
+ PharmacodynamicSbmlSerializer,
+)
+from .variables import VariableSerializer
+from .likelihoods import (
+ LogLikelihoodSerializer,
+ LogLikelihoodParameterSerializer,
+)
+from .inference import (
+ InferenceSerializer,
+ InferenceChainSerializer,
+ AlgorithmSerializer,
+)
+from .nca import NcaSerializer
+from .project import ProjectSerializer, ProjectAccessSerializer
+from .protocol import ProtocolSerializer
+from .dataset import DatasetSerializer, DatasetCsvSerializer
+from .subject import SubjectSerializer
+from .unit import UnitSerializer
+from .user import UserSerializer
+from .simulation import (
+ SimulationSerializer,
+ SimulationYAxisSerializer,
+ SimulationCxLineSerializer,
+ SimulationSliderSerializer,
+)
+
+
diff --git a/pkpdapp/pkpdapp/api/serializers/auce.py b/pkpdapp/pkpdapp/api/serializers/auce.py
new file mode 100644
index 00000000..e3bf81b2
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/auce.py
@@ -0,0 +1,39 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+
+
+class AuceSerializer(serializers.Serializer):
+ name = serializers.CharField()
+ fit_type = serializers.CharField()
+ subject_ids = serializers.ListField(
+ child=serializers.IntegerField()
+ )
+ concentrations = serializers.ListField(
+ child=serializers.FloatField()
+ )
+ auce = serializers.ListField(
+ child=serializers.FloatField()
+ )
+
+ x = serializers.ListField(
+ child=serializers.FloatField()
+ )
+ y = serializers.ListField(
+ child=serializers.FloatField()
+ )
+ y_upper = serializers.ListField(
+ child=serializers.FloatField()
+ )
+ y_lower = serializers.ListField(
+ child=serializers.FloatField()
+ )
+ fit_EC50 = serializers.FloatField()
+ sigma_EC50 = serializers.FloatField()
+ fit_top = serializers.FloatField()
+ sigma_top = serializers.FloatField()
+ fit_bottom = serializers.FloatField()
+ sigma_bottom = serializers.FloatField()
diff --git a/pkpdapp/pkpdapp/api/serializers/biomarker_type.py b/pkpdapp/pkpdapp/api/serializers/biomarker_type.py
new file mode 100644
index 00000000..7a862fea
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/biomarker_type.py
@@ -0,0 +1,30 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from typing import Dict, List
+from rest_framework import serializers
+from pkpdapp.models import (
+ BiomarkerType
+)
+
+
+class BiomarkerTypeSerializer(serializers.ModelSerializer):
+ data = serializers.SerializerMethodField('get_data')
+ is_continuous = serializers.SerializerMethodField('get_is_continuous')
+ is_categorical = serializers.SerializerMethodField('get_is_categorical')
+
+ class Meta:
+ model = BiomarkerType
+ fields = '__all__'
+
+ def get_data(self, bt) -> Dict[str, List] | None:
+ return bt.data().to_dict(orient='list')
+
+ def get_is_categorical(self, bt) -> bool:
+ return bt.is_categorical()
+
+ def get_is_continuous(self, bt) -> bool:
+ return bt.is_continuous()
diff --git a/pkpdapp/pkpdapp/api/serializers/compound.py b/pkpdapp/pkpdapp/api/serializers/compound.py
new file mode 100644
index 00000000..2de12fb6
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/compound.py
@@ -0,0 +1,64 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from rest_framework import serializers
+from pkpdapp.models import (
+ Compound
+)
+from pkpdapp.api.serializers import EfficacySerializer
+
+
+class BaseCompoundSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = Compound
+ fields = '__all__'
+
+
+class CompoundSerializer(serializers.ModelSerializer):
+ efficacy_experiments = EfficacySerializer(many=True)
+
+ class Meta:
+ model = Compound
+ fields = '__all__'
+
+ def create(self, validated_data):
+ # save method of log_likelihood will create its own parameters,
+ # so ignore any parameters that are given
+ experiments = validated_data.pop('efficacy_experiments')
+ compound = BaseCompoundSerializer().create(
+ validated_data
+ )
+ for exp in experiments:
+ exp['compound'] = compound
+ serializer = EfficacySerializer()
+ serializer.create(exp)
+ return compound
+
+ def update(self, instance, validated_data):
+ experiments = validated_data.pop('efficacy_experiments')
+ old_experiments = list(instance.efficacy_experiments.all())
+ project = BaseCompoundSerializer().update(
+ instance, validated_data
+ )
+ for exp in experiments:
+ exp['compound'] = instance
+ serializer = EfficacySerializer()
+ try:
+ old_experiment = old_experiments.pop(0)
+ new_exp = serializer.update(
+ old_experiment, exp
+ )
+ new_exp.save()
+ except IndexError:
+ new_exp = serializer.create(exp)
+
+ # delete any old accesses
+ for old_exp in old_experiments:
+ old_exp.delete()
+
+ project.refresh_from_db()
+
+ return project
diff --git a/pkpdapp/pkpdapp/api/serializers/dataset.py b/pkpdapp/pkpdapp/api/serializers/dataset.py
new file mode 100644
index 00000000..5dc9baec
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/dataset.py
@@ -0,0 +1,64 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from pkpdapp.utils import DataParser
+from rest_framework import serializers
+from drf_spectacular.utils import extend_schema_field
+import codecs
+from pkpdapp.models import (
+ Dataset, Protocol,
+)
+from pkpdapp.api.serializers import ProtocolSerializer
+
+
+class DatasetSerializer(serializers.ModelSerializer):
+ biomarker_types = serializers.PrimaryKeyRelatedField(
+ many=True, read_only=True
+ )
+ subjects = serializers.PrimaryKeyRelatedField(
+ many=True, read_only=True
+ )
+ protocols = serializers.SerializerMethodField('get_protocols')
+
+ class Meta:
+ model = Dataset
+ fields = '__all__'
+
+ @extend_schema_field(ProtocolSerializer(many=True))
+ def get_protocols(self, dataset):
+ protocols = [
+ Protocol.objects.get(pk=p['protocol'])
+ for p in dataset.subjects.values('protocol').distinct()
+ if p['protocol'] is not None
+ ]
+ return ProtocolSerializer(protocols, many=True).data
+
+
+class DatasetCsvSerializer(serializers.ModelSerializer):
+ csv = serializers.FileField()
+
+ class Meta:
+ model = Dataset
+ fields = ['csv']
+
+ def validate_csv(self, csv):
+ utf8_file = codecs.EncodedFile(csv.open(), "utf-8")
+ parser = DataParser()
+
+ # error in columns
+ try:
+ data = parser.parse_from_stream(utf8_file)
+ except RuntimeError as err:
+ raise serializers.ValidationError(str(err))
+ except UnicodeDecodeError as err:
+ raise serializers.ValidationError(str(err))
+
+ return data
+
+ def update(self, instance, validated_data):
+ data = validated_data['csv']
+ instance.replace_data(data)
+ return instance
diff --git a/pkpdapp/pkpdapp/api/serializers/dose.py b/pkpdapp/pkpdapp/api/serializers/dose.py
new file mode 100644
index 00000000..cf96a79a
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/dose.py
@@ -0,0 +1,16 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from rest_framework import serializers
+from pkpdapp.models import (
+ Dose
+)
+
+
+class DoseSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = Dose
+ exclude = ['protocol']
diff --git a/pkpdapp/pkpdapp/api/serializers/efficacy_experiment.py b/pkpdapp/pkpdapp/api/serializers/efficacy_experiment.py
new file mode 100644
index 00000000..d9657d33
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/efficacy_experiment.py
@@ -0,0 +1,16 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from rest_framework import serializers
+from pkpdapp.models import (
+ EfficacyExperiment
+)
+
+
+class EfficacySerializer(serializers.ModelSerializer):
+ class Meta:
+ model = EfficacyExperiment
+ fields = '__all__'
diff --git a/pkpdapp/pkpdapp/api/serializers/inference.py b/pkpdapp/pkpdapp/api/serializers/inference.py
new file mode 100644
index 00000000..4d0517eb
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/inference.py
@@ -0,0 +1,200 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+from pkpdapp.models import (
+ Inference, InferenceChain, Algorithm,
+ InferenceOutputResult,
+)
+import scipy.stats
+import numpy as np
+from pkpdapp.api.serializers import (
+ LogLikelihoodSerializer,
+)
+
+
+class InferenceOutputResultSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = InferenceOutputResult
+ fields = '__all__'
+
+
+class AlgorithmSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = Algorithm
+ fields = '__all__'
+
+
+class BaseInferenceSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = Inference
+ fields = '__all__'
+
+
+class InferenceSerializer(serializers.ModelSerializer):
+
+ log_likelihoods = LogLikelihoodSerializer(
+ many=True
+ )
+
+ class Meta:
+ model = Inference
+ fields = '__all__'
+
+ def validate_log_likelihoods(self, value):
+ """
+ Check that the blog post is about Django.
+ """
+ names = [v['name'] for v in value]
+ if len(set(names)) < len(names):
+ raise serializers.ValidationError(
+ "all log_likelihoods in an inference must have unique names"
+ )
+ return value
+
+ def create(self, validated_data):
+ log_likelihood_data = validated_data.pop('log_likelihoods')
+ new_inference = BaseInferenceSerializer().create(
+ validated_data
+ )
+ for field_datas, Serializer in [
+ (log_likelihood_data, LogLikelihoodSerializer),
+ ]:
+ for field_data in field_datas:
+ serializer = Serializer()
+ field_data['inference'] = new_inference
+ serializer.create(field_data)
+
+ return new_inference
+
+ def update(self, instance, validated_data):
+ log_likelihood_data = validated_data.pop('log_likelihoods')
+ old_log_likelihoods = list((instance.log_likelihoods).all())
+
+ # if read_only only update name, description and burnin
+ if instance.read_only:
+ validated_data = {
+ key: validated_data[key]
+ for key in ['name', 'description', 'burn_in']
+ if key in validated_data
+ }
+
+ new_inference = BaseInferenceSerializer().update(
+ instance, validated_data
+ )
+
+ # don't update log_likelihoods if read_only
+ if not instance.read_only:
+ for field_datas, old_models, Serializer in [
+ (log_likelihood_data,
+ old_log_likelihoods, LogLikelihoodSerializer)
+ ]:
+ for field_data in field_datas:
+ serializer = Serializer()
+ try:
+ old_model = old_models.pop(0)
+ new_model = serializer.update(
+ old_model, field_data
+ )
+ except IndexError:
+ field_data['inference'] = new_inference
+ new_model = serializer.create(field_data)
+ new_model.save()
+
+ return new_inference
+
+
+class InferenceChainSerializer(serializers.ModelSerializer):
+ data = serializers.SerializerMethodField('get_data')
+ outputs = serializers.SerializerMethodField('get_outputs')
+
+ class Meta:
+ model = InferenceChain
+ fields = '__all__'
+
+ def get_outputs(self, inference_chain):
+ outputs = {
+ ll.id: inference_chain.outputs_for(ll).to_dict(orient='list')
+ for ll in inference_chain.inference.log_likelihoods.all()
+ if ll.has_data()
+ }
+ return outputs
+
+ def get_data(self, inference_chain):
+ chain = inference_chain.as_pandas()
+ function_values = inference_chain.function_as_pandas()
+ by_priors = chain.groupby(['priors', 'subjects'], dropna=False)
+
+ chain = {}
+ kde = {}
+
+ for (prior, subject), frame in by_priors:
+ values = frame['values']
+
+ # get kde density of chains
+ min_value = values.min()
+ max_value = values.max()
+ kde_values = np.linspace(min_value, max_value, 100)
+ try:
+ kde_densities = scipy.stats.gaussian_kde(values)(kde_values)
+ except np.linalg.LinAlgError:
+ kde[int(prior)] = {
+ 'values': [],
+ 'densities': [],
+ }
+ continue
+
+ if np.isnan(subject):
+ kde[int(prior)] = {
+ 'values': kde_values.tolist(),
+ 'densities': kde_densities.tolist(),
+ }
+ else:
+ if prior not in kde:
+ kde[int(prior)] = {}
+ kde[int(prior)][int(subject)] = {
+ 'values': kde_values.tolist(),
+ 'densities': kde_densities.tolist(),
+ }
+
+ # reduce to max 500 values for each prior
+ sample_n = 500
+ for (prior, subject), frame in by_priors:
+ if frame['values'].count() > sample_n:
+ sampled_frame = frame.sample(n=sample_n).sort_index()
+ else:
+ sampled_frame = frame
+ values = sampled_frame['values']
+ iterations = sampled_frame['iterations']
+ if np.isnan(subject):
+ chain[int(prior)] = {
+ 'values': values.tolist(),
+ 'iterations': iterations.tolist()
+ }
+ else:
+ if prior not in chain:
+ chain[int(prior)] = {}
+ chain[int(prior)][int(subject)] = {
+ 'values': values.tolist(),
+ 'iterations': iterations.tolist()
+ }
+
+ if len(function_values.index) > sample_n:
+ function_values = function_values.sample(n=sample_n).sort_index()
+
+ # inf & nan values not serializable
+ function_values.replace([np.inf, -np.inf], np.nan, inplace=True)
+ function_values.fillna('', inplace=True)
+
+ function_values = {
+ 'values': function_values['values'].tolist(),
+ 'iterations': function_values['iterations'],
+ }
+
+ return {
+ 'kde': kde,
+ 'chain': chain,
+ 'function': function_values,
+ }
diff --git a/pkpdapp/pkpdapp/api/serializers/likelihoods.py b/pkpdapp/pkpdapp/api/serializers/likelihoods.py
new file mode 100644
index 00000000..7e19bc88
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/likelihoods.py
@@ -0,0 +1,90 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from django.db.models import Q
+from typing import Tuple
+from rest_framework import serializers
+from pkpdapp.models import (
+ LogLikelihood, LogLikelihoodParameter,
+)
+
+
+class LogLikelihoodParameterSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = LogLikelihoodParameter
+ fields = '__all__'
+ read_only_fields = ("parent", )
+
+
+class BaseLogLikelihoodSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = LogLikelihood
+ fields = '__all__'
+
+
+class LogLikelihoodSerializer(serializers.ModelSerializer):
+ parameters = LogLikelihoodParameterSerializer(
+ many=True
+ )
+ model = serializers.SerializerMethodField('get_model')
+ dataset = serializers.SerializerMethodField('get_dataset')
+ time_variable = serializers.SerializerMethodField('get_time_variable')
+ is_a_prior = serializers.SerializerMethodField('get_is_a_prior')
+
+ class Meta:
+ model = LogLikelihood
+ fields = '__all__'
+ read_only_fields = ("inference", )
+
+ def get_time_variable(self, instance) -> int | None:
+ model = instance.get_model()
+ if model is not None:
+ time_variable = model.variables.get(
+ Q(name='time') | Q(name='t')
+ )
+ return time_variable.id
+
+ def get_is_a_prior(self, instance) -> bool:
+ return instance.is_a_prior()
+
+ def get_model(self, instance) -> Tuple[str, int] | None:
+ model = instance.get_model()
+ if model is not None:
+ return (model._meta.db_table, model.id)
+
+ def get_dataset(self, instance) -> int | None:
+ if instance.biomarker_type:
+ return instance.biomarker_type.dataset.id
+
+ def create(self, validated_data):
+ # save method of log_likelihood will create its own parameters,
+ # so ignore any parameters that are given
+ validated_data.pop('parameters')
+ new_log_likelihood = BaseLogLikelihoodSerializer().create(
+ validated_data
+ )
+ return new_log_likelihood
+
+ def update(self, instance, validated_data):
+ parameters_data = validated_data.pop('parameters')
+ old_parameters = list((instance.parameters).all())
+ new_log_likelihood = BaseLogLikelihoodSerializer().update(
+ instance, validated_data
+ )
+
+ # update params with new info
+ for field_datas, old_models, Serializer in [
+ (parameters_data, old_parameters,
+ LogLikelihoodParameterSerializer),
+ ]:
+ for field_data in field_datas:
+ serializer = Serializer()
+ old_model = old_parameters.pop(0)
+ new_model = serializer.update(
+ old_model, field_data
+ )
+ new_model.save()
+
+ return new_log_likelihood
diff --git a/pkpdapp/pkpdapp/api/serializers/models.py b/pkpdapp/pkpdapp/api/serializers/models.py
new file mode 100644
index 00000000..66558668
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/models.py
@@ -0,0 +1,220 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+from pkpdapp.models import (
+ PharmacokineticModel,
+ CombinedModel,
+ PharmacodynamicModel,
+ PkpdMapping,
+ MyokitModelMixin,
+ DerivedVariable,
+ Variable,
+)
+from pkpdapp.api.serializers import ValidSbml, ValidMmt
+
+
+class PkpdMappingSerializer(serializers.ModelSerializer):
+ datetime = serializers.DateField(read_only=True, required=False)
+ read_only = serializers.BooleanField(read_only=True, required=False)
+
+ class Meta:
+ model = PkpdMapping
+ fields = "__all__"
+
+
+class DerivedVariableSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = DerivedVariable
+ fields = "__all__"
+
+
+class BaseDosedPharmacokineticSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = CombinedModel
+ fields = "__all__"
+
+
+class CombinedModelSerializer(serializers.ModelSerializer):
+ mappings = PkpdMappingSerializer(many=True)
+ derived_variables = DerivedVariableSerializer(many=True)
+ components = serializers.SerializerMethodField("get_components")
+ variables = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
+ mmt = serializers.SerializerMethodField("get_mmt", read_only=True)
+ time_unit = serializers.SerializerMethodField("get_time_unit")
+ is_library_model = serializers.SerializerMethodField("get_is_library_model")
+
+ class Meta:
+ model = CombinedModel
+ fields = "__all__"
+
+ def get_is_library_model(self, m) -> bool:
+ return m.is_library_model
+
+ def get_mmt(self, m) -> str:
+ return m.get_mmt()
+
+ def get_time_unit(self, m) -> int:
+ unit = m.get_time_unit()
+ if unit is None:
+ return -1
+ else:
+ return unit.id
+
+ def get_components(self, m):
+ model = m.get_myokit_model()
+ return [_serialize_component(m, c, model) for c in model.components(sort=True)]
+
+ def create(self, validated_data):
+ mappings_data = validated_data.pop("mappings", [])
+ derived_variables_data = validated_data.pop("derived_variables", [])
+ new_pkpd_model = BaseDosedPharmacokineticSerializer().create(validated_data)
+ for field_datas, Serializer in [
+ (mappings_data, PkpdMappingSerializer),
+ (derived_variables_data, DerivedVariableSerializer),
+ ]:
+ for field_data in field_datas:
+ serializer = Serializer()
+ field_data["pkpd_model"] = new_pkpd_model
+ serializer.create(field_data)
+
+ return new_pkpd_model
+
+ def update(self, instance, validated_data):
+ mappings_data = validated_data.pop("mappings", [])
+ derived_var_data = validated_data.pop("derived_variables", [])
+ old_mappings = list((instance.mappings).all())
+ old_derived_vars = list((instance.derived_variables).all())
+
+ pk_model_changed = False
+ if "pk_model" in validated_data:
+ pk_model_changed = instance.pk_model != validated_data.get("pk_model")
+ pd_model_changed = False
+ if "pd_model" in validated_data:
+ pd_model_changed = instance.pd_model != validated_data.get("pd_model")
+
+ new_pkpd_model = BaseDosedPharmacokineticSerializer().update(
+ instance, validated_data
+ )
+
+ # if pd model has changed, update effect variable
+ if pd_model_changed:
+ for mapping in mappings_data:
+ try:
+ mapping["pd_variable"] = new_pkpd_model.variables.get(
+ qname=mapping["pd_variable"].qname
+ )
+ except Variable.DoesNotExist:
+ mapping["pd_variable"] = None
+
+ mappings_data = [m for m in mappings_data if m["pd_variable"] is not None]
+
+ # don't update mappings if read_only
+ # don't update mapping or derived variables if pk model has changed
+ if not (instance.read_only or pk_model_changed):
+ for derived_var in derived_var_data:
+ serializer = DerivedVariableSerializer()
+ try:
+ old_model = old_derived_vars.pop(0)
+ new_model = serializer.update(old_model, derived_var)
+ new_model.save()
+ except IndexError:
+ derived_var["pkpd_model"] = new_pkpd_model
+ new_model = serializer.create(derived_var)
+
+ for mapping in mappings_data:
+ serializer = PkpdMappingSerializer()
+ try:
+ old_model = old_mappings.pop(0)
+ new_model = serializer.update(old_model, mapping)
+ new_model.save()
+ except IndexError:
+ mapping["pkpd_model"] = new_pkpd_model
+ new_model = serializer.create(mapping)
+
+ # delete any remaining old mappings and derived variables
+ for old_model in old_mappings:
+ old_model.delete()
+ for old_model in old_derived_vars:
+ old_model.delete()
+
+ # update model since mappings might have changed
+ new_pkpd_model.update_model()
+
+ return new_pkpd_model
+
+
+class PharmacokineticSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = PharmacokineticModel
+ fields = "__all__"
+
+
+def _serialize_component(model, component, myokit_model):
+ states = [
+ v.pk
+ for v in model.variables.filter(state=True)
+ if v.qname.startswith(component.name())
+ ]
+
+ variables = [
+ v.pk
+ for v in model.variables.filter(constant=True)
+ if v.qname.startswith(component.name())
+ ]
+
+ outputs = [
+ v.pk
+ for v in model.variables.filter(constant=False)
+ if v.qname.startswith(component.name())
+ ]
+
+ equations = [
+ MyokitModelMixin._serialise_equation(e)
+ for e in component.equations(bound=False, const=False)
+ ]
+ return {
+ "name": component.name(),
+ "states": states,
+ "variables": variables,
+ "outputs": outputs,
+ "equations": equations,
+ }
+
+
+class PharmacodynamicSerializer(serializers.ModelSerializer):
+ components = serializers.SerializerMethodField("get_components")
+ variables = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
+ mmt = serializers.CharField(validators=[ValidMmt()], required=False)
+
+ def get_components(self, m):
+ model = m.get_myokit_model()
+ return [_serialize_component(m, c, model) for c in model.components(sort=True)]
+
+ class Meta:
+ model = PharmacodynamicModel
+ fields = "__all__"
+
+
+class PharmacodynamicSbmlSerializer(serializers.ModelSerializer):
+ sbml = serializers.CharField(validators=[ValidSbml()], write_only=True)
+
+ class Meta:
+ model = PharmacodynamicModel
+ fields = ["sbml"]
+ extra_kwargs = {"sbml": {"write_only": True}}
+
+ def create(self, validated_data):
+ sbml = validated_data.pop("sbml")
+ mmt = MyokitModelMixin.sbml_string_to_mmt(sbml)
+ validated_data["mmt"] = mmt
+ return PharmacodynamicModel(**validated_data)
+
+ def update(self, instance, validated_data):
+ sbml = validated_data.get("sbml")
+ mmt = MyokitModelMixin.sbml_string_to_mmt(sbml)
+ instance.mmt = mmt
+ instance.save()
+ return instance
diff --git a/pkpdapp/pkpdapp/api/serializers/monolix.py b/pkpdapp/pkpdapp/api/serializers/monolix.py
new file mode 100644
index 00000000..67013ab0
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/monolix.py
@@ -0,0 +1,100 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from pkpdapp.utils import (
+ MonolixModelParser,
+ monolix_import,
+)
+from rest_framework import serializers
+import codecs
+from pkpdapp.models import (
+ Project,
+)
+
+
+class MonolixSerializer(serializers.ModelSerializer):
+ data_csv = serializers.FileField(write_only=True)
+ model_txt = serializers.FileField(write_only=True)
+ project_mlxtran = serializers.FileField(write_only=True)
+ data = serializers.PrimaryKeyRelatedField(read_only=True)
+ pd_model = serializers.PrimaryKeyRelatedField(read_only=True)
+ pk_model = serializers.PrimaryKeyRelatedField(read_only=True)
+
+ class Meta:
+ model = Project
+ fields = ['data_csv', 'model_txt', 'project_mlxtran',
+ 'data', 'pd_model', 'pk_model']
+
+ def validate_data_csv(self, data_csv):
+ utf8_file = codecs.EncodedFile(data_csv.open(), "utf-8")
+ # error in columns
+ try:
+ utf8_str = codecs.decode(utf8_file.read(), 'utf-8')
+ except RuntimeError as err:
+ raise serializers.ValidationError(str(err))
+ except UnicodeDecodeError as err:
+ raise serializers.ValidationError(str(err))
+
+ return utf8_str
+
+ def validate_model_txt(self, model_txt):
+ utf8_file = codecs.EncodedFile(model_txt.open(), "utf-8")
+ parser = MonolixModelParser()
+
+ # error in columns
+ try:
+ utf8_str = codecs.decode(utf8_file.read(), 'utf-8')
+ parser.parse(utf8_str)
+ except RuntimeError as err:
+ raise serializers.ValidationError(str(err))
+ except UnicodeDecodeError as err:
+ raise serializers.ValidationError(str(err))
+
+ return utf8_str
+
+ def validate_project_mlxtran(self, project_mlxtran):
+ utf8_file = codecs.EncodedFile(project_mlxtran.open(), "utf-8")
+ # error in columns
+ try:
+ utf8_str = codecs.decode(utf8_file.read(), 'utf-8')
+ except RuntimeError as err:
+ raise serializers.ValidationError(str(err))
+ except UnicodeDecodeError as err:
+ raise serializers.ValidationError(str(err))
+
+ return utf8_str
+
+ def validate(self, data):
+ instance = getattr(self, 'instance', None)
+ if instance is None:
+ raise serializers.ValidationError('project instance must exist')
+ try:
+ monolix_import(instance, data['project_mlxtran'],
+ data['model_txt'], data['data_csv'], validate=True)
+ except RuntimeError as err:
+ raise serializers.ValidationError(str(err))
+ except UnicodeDecodeError as err:
+ raise serializers.ValidationError(str(err))
+ return data
+
+ def update(self, instance, validated_data):
+ result = monolix_import(
+ instance, validated_data['project_mlxtran'],
+ validated_data['model_txt'], validated_data['data_csv'],
+ validate=False
+ )
+ if result is None:
+ return None
+ result_dict = {
+ 'data_csv': validated_data['data_csv'],
+ 'model_txt': validated_data['model_txt'],
+ 'project_mlxtran': validated_data['project_mlxtran'],
+ 'pd_model': result[0],
+ 'pk_model': result[1],
+ 'data': result[2],
+ }
+ print('result_dict: ', result_dict)
+ return result_dict
diff --git a/pkpdapp/pkpdapp/api/serializers/nca.py b/pkpdapp/pkpdapp/api/serializers/nca.py
new file mode 100644
index 00000000..c4b3a477
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/nca.py
@@ -0,0 +1,37 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+
+
+class NcaSerializer(serializers.Serializer):
+ times = serializers.ListField(
+ child=serializers.FloatField()
+ )
+ concentrations = serializers.ListField(
+ child=serializers.FloatField()
+ )
+ dose_amount = serializers.FloatField()
+ administration_route = serializers.CharField()
+ c_0 = serializers.FloatField()
+ auc_0_last = serializers.FloatField()
+ aumc_0_last = serializers.FloatField()
+ lambda_z = serializers.FloatField()
+ r2 = serializers.FloatField()
+ num_points = serializers.IntegerField(min_value=0)
+ auc_infinity = serializers.FloatField()
+ auc_infinity_dose = serializers.FloatField()
+ auc_extrap_percent = serializers.FloatField()
+ cl = serializers.FloatField()
+ c_max = serializers.FloatField()
+ t_max = serializers.FloatField()
+ c_max_dose = serializers.FloatField()
+ aumc = serializers.FloatField()
+ aumc_extrap_percent = serializers.FloatField()
+ mrt = serializers.FloatField()
+ tlast = serializers.FloatField()
+ t_half = serializers.FloatField()
+ v_ss = serializers.FloatField()
+ v_z = serializers.FloatField()
diff --git a/pkpdapp/pkpdapp/api/serializers/polymorphicserializer.py b/pkpdapp/pkpdapp/api/serializers/polymorphicserializer.py
new file mode 100644
index 00000000..320cce27
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/polymorphicserializer.py
@@ -0,0 +1,102 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+# This code was derived from
+# https://stackoverflow.com/questions/48911345/drf-how-to-serialize-models-inheritance-read-write
+
+from enum import Enum
+
+from rest_framework import serializers
+
+
+class PolymorphicSerializer(serializers.Serializer):
+ """
+ Serializer to handle multiple subclasses of another class
+
+ - For serialized dict representations, a 'type' key with the class name as
+ the value is expected: ex. {'type': 'Decimal', ... }
+ - This type information is used in tandem with get_serializer_map(...) to
+ manage serializers for multiple subclasses
+
+ """
+
+ def get_serializer_map(self):
+ """
+ Return a dict to map class names to their respective serializer classes
+
+ To be implemented by all PolymorphicSerializer subclasses
+ """
+ raise NotImplementedError
+
+ def to_representation(self, obj):
+ """
+ Translate object to internal data representation
+
+ Override to allow polymorphism
+ """
+ if hasattr(obj, 'get_type'):
+ type_ = obj.get_type()
+ if isinstance(type_, Enum):
+ type_str = type_.value
+ else:
+ type_str = type_.__name__
+
+ else:
+ type_str = obj.__class__.__name__
+
+ try:
+ serializer = self.get_serializer_map()[type_str]
+ except KeyError:
+ raise ValueError(
+ 'Serializer for "{}" does not exist'.format(type_str),
+ )
+
+ data = serializer(obj, context=self.context).to_representation(obj)
+ data['type'] = type_str
+ return data
+
+ def to_internal_value(self, data):
+ """
+ Validate data and initialize primitive types
+
+ Override to allow polymorphism
+ """
+ try:
+ type_str = data['type']
+ except KeyError:
+ raise serializers.ValidationError({
+ 'type': 'This field is required',
+ })
+
+ try:
+ serializer = self.get_serializer_map()[type_str]
+ except KeyError:
+ raise serializers.ValidationError({
+ 'type': 'Serializer for "{}" does not exist'.format(type_str),
+ })
+
+ validated_data = serializer(
+ context=self.context
+ ).to_internal_value(data)
+ validated_data['type'] = type_str
+ return validated_data
+
+ def create(self, validated_data):
+ """
+ Translate validated data representation to object
+
+ Override to allow polymorphism
+ """
+ serializer = self.get_serializer_map()[validated_data['type']]
+ validated_data.pop('type')
+ return serializer(context=self.context).create(validated_data)
+
+ def update(self, instance, validated_data):
+ serializer = self.get_serializer_map()[validated_data['type']]
+ validated_data.pop('type')
+
+ return serializer(context=self.context).update(
+ instance, validated_data
+ )
diff --git a/pkpdapp/pkpdapp/api/serializers/project.py b/pkpdapp/pkpdapp/api/serializers/project.py
new file mode 100644
index 00000000..0c388e3b
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/project.py
@@ -0,0 +1,78 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+from pkpdapp.models import (
+ ProjectAccess, Project
+)
+
+
+class ProjectAccessSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = ProjectAccess
+ fields = '__all__'
+ read_only_fields = ("project", )
+
+
+class BaseProjectSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = Project
+ fields = '__all__'
+
+
+class ProjectSerializer(serializers.ModelSerializer):
+ user_access = ProjectAccessSerializer(
+ source='projectaccess_set', many=True
+ )
+ protocols = serializers.PrimaryKeyRelatedField(
+ many=True, read_only=True
+ )
+
+ class Meta:
+ model = Project
+ fields = '__all__'
+ read_only_fields = ("created", )
+
+ def create(self, validated_data):
+ # save method of log_likelihood will create its own parameters,
+ # so ignore any parameters that are given
+ users = validated_data.pop('projectaccess_set')
+ project = BaseProjectSerializer().create(
+ validated_data
+ )
+ for user in users:
+ user['project'] = project
+ serializer = ProjectAccessSerializer()
+ serializer.create(user)
+ return project
+
+ def update(self, instance, validated_data):
+ print('project update', validated_data)
+ users = validated_data.pop('projectaccess_set')
+ old_accesses = list(instance.projectaccess_set.all())
+ project = BaseProjectSerializer().update(
+ instance, validated_data
+ )
+ for user in users:
+ user['project_id'] = instance.id
+ serializer = ProjectAccessSerializer()
+ old_access = [
+ i for i, a in enumerate(old_accesses) if a.user == user['user']
+ ]
+ if not old_access:
+ new_access = serializer.create(user)
+ else:
+ new_access = serializer.update(
+ old_accesses.pop(old_access[0]), user
+ )
+ new_access.save()
+
+ # delete any old accesses
+ for old_access in old_accesses:
+ old_access.delete()
+
+ project.refresh_from_db()
+
+ return project
diff --git a/pkpdapp/pkpdapp/api/serializers/protocol.py b/pkpdapp/pkpdapp/api/serializers/protocol.py
new file mode 100644
index 00000000..fc02a9dc
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/protocol.py
@@ -0,0 +1,45 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+from pkpdapp.models import (
+ Dose, Protocol
+)
+from pkpdapp.api.serializers import DoseSerializer
+
+
+class ProtocolSerializer(serializers.ModelSerializer):
+ doses = DoseSerializer(
+ many=True
+ )
+ dataset = serializers.SerializerMethodField('get_dataset')
+ variables = serializers.PrimaryKeyRelatedField(
+ many=True, read_only=True
+ )
+ subjects = serializers.PrimaryKeyRelatedField(
+ many=True, read_only=True
+ )
+
+ class Meta:
+ model = Protocol
+ fields = '__all__'
+
+ def get_dataset(self, protocol):
+ return protocol.get_dataset()
+
+ def create(self, validated_data):
+ doses = validated_data.pop('doses')
+ protocol = Protocol.objects.create(**validated_data)
+ for dose in doses:
+ Dose.objects.create(protocol=protocol, **dose)
+ return protocol
+
+ def update(self, instance, validated_data):
+ doses = validated_data.pop('doses')
+ Dose.objects.filter(protocol=instance).delete()
+ for dose in doses:
+ dose['protocol'] = instance
+ DoseSerializer.create(DoseSerializer(), dose)
+ return super().update(instance, validated_data)
diff --git a/pkpdapp/pkpdapp/api/serializers/simulation.py b/pkpdapp/pkpdapp/api/serializers/simulation.py
new file mode 100644
index 00000000..c2ea3624
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/simulation.py
@@ -0,0 +1,100 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from rest_framework import serializers
+from pkpdapp.models import (
+ Simulation, SimulationYAxis, SimulationSlider,
+ SimulationCxLine, SimulationPlot
+)
+
+
+class SimulationYAxisSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = SimulationYAxis
+ exclude = ['plot']
+
+
+class SimulationSliderSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = SimulationSlider
+ exclude = ['simulation']
+
+
+class SimulationCxLineSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = SimulationCxLine
+ exclude = ['plot']
+
+
+class SimulationPlotSerializer(serializers.ModelSerializer):
+ y_axes = SimulationYAxisSerializer(
+ many=True
+ )
+ cx_lines = SimulationCxLineSerializer(
+ many=True
+ )
+
+ class Meta:
+ model = SimulationPlot
+ # fields = '__all__'
+ exclude = ['simulation']
+
+ def create(self, validated_data):
+ y_axes_data = validated_data.pop('y_axes')
+ cx_lines_data = validated_data.pop('cx_lines')
+ plot = SimulationPlot.objects.create(**validated_data)
+ for y_axis in y_axes_data:
+ SimulationYAxis.objects.create(plot=plot, **y_axis)
+ for cx_line in cx_lines_data:
+ SimulationCxLine.objects.create(plot=plot, **cx_line)
+ return plot
+
+ def update(self, instance, validated_data):
+ y_axes_data = validated_data.pop('y_axes')
+ cx_lines_data = validated_data.pop('cx_lines')
+ SimulationYAxis.objects.filter(plot=instance).delete()
+ SimulationCxLine.objects.filter(plot=instance).delete()
+ for y_axis in y_axes_data:
+ SimulationYAxis.objects.create(plot=instance, **y_axis)
+ for cx_line in cx_lines_data:
+ SimulationCxLine.objects.create(plot=instance, **cx_line)
+ return super().update(instance, validated_data)
+
+
+class SimulationSerializer(serializers.ModelSerializer):
+ sliders = SimulationSliderSerializer(
+ many=True
+ )
+ plots = SimulationPlotSerializer(
+ many=True
+ )
+
+ class Meta:
+ model = Simulation
+ fields = '__all__'
+
+ def create(self, validated_data):
+ slider_data = validated_data.pop('sliders')
+ plot_data = validated_data.pop('plots')
+ simulation = Simulation.objects.create(**validated_data)
+ for slider in slider_data:
+ SimulationSlider.objects.create(simulation=simulation, **slider)
+ for plot in plot_data:
+ plot['simulation'] = simulation
+ SimulationPlotSerializer.create(SimulationPlotSerializer(), plot)
+ return simulation
+
+ def update(self, instance, validated_data):
+ slider_data = validated_data.pop('sliders')
+ plot_data = validated_data.pop('plots')
+ SimulationSlider.objects.filter(simulation=instance).delete()
+ SimulationPlot.objects.filter(simulation=instance).delete()
+ for slider in slider_data:
+ SimulationSlider.objects.create(simulation=instance, **slider)
+ for plot in plot_data:
+ plot['simulation'] = instance
+ SimulationPlotSerializer.create(SimulationPlotSerializer(), plot)
+ return super().update(instance, validated_data)
diff --git a/pkpdapp/pkpdapp/api/serializers/subject.py b/pkpdapp/pkpdapp/api/serializers/subject.py
new file mode 100644
index 00000000..c2a62bdb
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/subject.py
@@ -0,0 +1,15 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+from pkpdapp.models import (
+ Subject,
+)
+
+
+class SubjectSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = Subject
+ fields = '__all__'
diff --git a/pkpdapp/pkpdapp/api/serializers/unit.py b/pkpdapp/pkpdapp/api/serializers/unit.py
new file mode 100644
index 00000000..f131ce3e
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/unit.py
@@ -0,0 +1,44 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from pkpdapp.models import Unit
+from rest_framework.schemas.openapi import AutoSchema
+from rest_framework import serializers
+from typing import Dict, List
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class UnitSchema(AutoSchema):
+ """
+ AutoSchema subclass that knows how to use extra_info.
+ """
+
+ ...
+
+
+class UnitSerializer(serializers.ModelSerializer):
+ compatible_units = serializers.SerializerMethodField("get_compatible_units")
+
+ class Meta:
+ model = Unit
+ fields = "__all__"
+
+ def get_compatible_units(self, unit) -> List[Dict[str, str]]:
+ compound = self.context.get("compound")
+ return [
+ {
+ "id": u.id,
+ "symbol": u.symbol,
+ "conversion_factor": unit.convert_to(
+ u, compound=compound, is_target=False
+ ),
+ "target_conversion_factor": unit.convert_to(
+ u, compound=compound, is_target=True
+ ),
+ }
+ for u in unit.get_compatible_units(compound=compound)
+ ]
diff --git a/pkpdapp/pkpdapp/api/serializers/user.py b/pkpdapp/pkpdapp/api/serializers/user.py
new file mode 100644
index 00000000..2e7a4bff
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/user.py
@@ -0,0 +1,31 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+from django.contrib.auth.models import User
+from pkpdapp.models import (
+ Profile
+)
+
+
+class ProfileSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = Profile
+ fields = '__all__'
+
+
+class UserSerializer(serializers.ModelSerializer):
+ profile = ProfileSerializer(read_only=True)
+ project_set = serializers.PrimaryKeyRelatedField(
+ many=True, read_only=True,
+ )
+
+ class Meta:
+ model = User
+ fields = '__all__'
+ fields = (
+ 'id', 'username', 'first_name',
+ 'last_name', 'email', 'profile', 'project_set'
+ )
diff --git a/pkpdapp/pkpdapp/api/serializers/validators.py b/pkpdapp/pkpdapp/api/serializers/validators.py
new file mode 100644
index 00000000..3e398045
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/validators.py
@@ -0,0 +1,25 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+from pkpdapp.models.mechanistic_model import MyokitModelMixin
+from myokit.formats.sbml import SBMLParsingError
+import myokit
+
+
+class ValidSbml:
+ def __call__(self, value):
+ try:
+ MyokitModelMixin.parse_sbml_string(value)
+ except SBMLParsingError as e:
+ raise serializers.ValidationError(e)
+
+
+class ValidMmt:
+ def __call__(self, value):
+ try:
+ MyokitModelMixin.parse_mmt_string(value)
+ except myokit.ParseError as e:
+ raise serializers.ValidationError(e)
diff --git a/pkpdapp/pkpdapp/api/serializers/variables.py b/pkpdapp/pkpdapp/api/serializers/variables.py
new file mode 100644
index 00000000..59fc4be0
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/serializers/variables.py
@@ -0,0 +1,25 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import serializers
+from pkpdapp.models import (
+ Variable,
+)
+
+
+class VariableSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = Variable
+ fields = "__all__"
+
+ def to_internal_value(self, data):
+ optional_fields = [
+ "lower_bound",
+ "upper_bound",
+ ]
+ for field in optional_fields:
+ if data.get(field, None) == "":
+ data[field] = None
+ return super(VariableSerializer, self).to_internal_value(data)
diff --git a/pkpdapp/pkpdapp/api/views/__init__.py b/pkpdapp/pkpdapp/api/views/__init__.py
new file mode 100644
index 00000000..f51fe248
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/__init__.py
@@ -0,0 +1,51 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+# flake8: noqa F401
+
+
+from .login import (login_view, logout_view, get_csrf, SessionView, WhoAmIView)
+from .filters import (
+ UserAccessFilter,
+ DosedPkModelFilter,
+ PdModelFilter,
+ ProjectFilter,
+ InferenceFilter
+)
+from .permissions import (
+ NotADatasetDose,
+ NotADatasetProtocol,
+ CheckAccessToProject,
+)
+from .simulation import (
+ SimulationViewSet,
+)
+from .auce import AuceView
+from .biomarker_type import BiomarkerTypeView
+from .dataset import DatasetView
+from .dose import DoseView
+from .compound import CompoundView
+
+from .models import (
+ PharmacokineticView,
+ PharmacodynamicView,
+ CombinedModelView,
+)
+from .nca import NcaView
+from .project import ProjectView, ProjectAccessView
+from .protocol import ProtocolView
+from .inference import (
+ InferenceView, InferenceChainView, AlgorithmView,
+ StopInferenceView, InferenceWizardView,
+)
+from .simulate import (
+ SimulateCombinedView,
+ SimulatePdView,
+)
+from .subject import SubjectView
+from .unit import UnitView
+from .user import UserView
+from .variable import VariableView
+from .likelihoods import LogLikelihoodView
diff --git a/pkpdapp/pkpdapp/api/views/auce.py b/pkpdapp/pkpdapp/api/views/auce.py
new file mode 100644
index 00000000..985765f1
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/auce.py
@@ -0,0 +1,117 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import (
+ views, status
+)
+from rest_framework.response import Response
+from pkpdapp.models import (
+ BiomarkerType,
+)
+from pkpdapp.api.serializers import AuceSerializer
+from pkpdapp.utils import Auce
+
+
+class AuceView(views.APIView):
+ def post(self, request, format=None):
+ errors = {
+ }
+
+ biomarker_type_id = request.data.get('biomarker_type_id', None)
+ if biomarker_type_id is None:
+ errors['biomarker_type_id'] = "This field is required"
+ else:
+ try:
+ biomarker_type = \
+ BiomarkerType.objects.get(id=biomarker_type_id)
+ except BiomarkerType.DoesNotExist:
+ errors['biomarker_type_id'] = (
+ "BiomarkerType id {} not found"
+ .format(biomarker_type_id)
+ )
+
+ group_type_id = request.data.get('group_type_id', None)
+ if group_type_id is None:
+ errors['group_type_id'] = "This field is required"
+ else:
+ try:
+ group_type = \
+ BiomarkerType.objects.get(id=group_type_id)
+ except BiomarkerType.DoesNotExist:
+ errors['group_type_id'] = (
+ "BiomarkerType id {} not found"
+ .format(biomarker_type_id)
+ )
+
+ concentration_type_id = request.data.get('concentration_type_id', None)
+ if concentration_type_id is None:
+ errors['concentration_type_id'] = "This field is required"
+ else:
+ try:
+ concentration_type = \
+ BiomarkerType.objects.get(id=concentration_type_id)
+ except BiomarkerType.DoesNotExist:
+ errors['group_type_id'] = (
+ "BiomarkerType id {} not found"
+ .format(concentration_type_id)
+ )
+
+ if errors:
+ return Response(
+ errors, status=status.HTTP_400_BAD_REQUEST
+ )
+
+ group_data = group_type.data(first_time_only=True)
+ groups = list(group_data['values'].unique()) + [None]
+ obs_data = biomarker_type.data()
+ concentration_data = concentration_type.data(first_time_only=True)
+
+ auces = []
+ for group in groups:
+ if group is None:
+ group_subjects = group_data['subjects'].unique()
+ else:
+ group_subjects = group_data.loc[
+ group_data['values'] == group
+ ]['subjects']
+ group_concentrations = concentration_data[
+ concentration_data['subjects'].isin(group_subjects)
+ ]
+ group_obs_data = obs_data[
+ obs_data['subjects'].isin(group_subjects)
+ ]
+
+ subject_times = []
+ subject_data = []
+ concentrations = []
+ subject_ids = []
+ for subject in group_subjects:
+ times = group_obs_data.loc[
+ group_obs_data['subjects'] == subject
+ ]['times']
+ values = group_obs_data.loc[
+ group_obs_data['subjects'] == subject
+ ]['values']
+ concentration = group_concentrations.loc[
+ group_concentrations['subjects'] == subject
+ ]['values'].iloc[0]
+ concentrations.append(concentration)
+ subject_times.append(times)
+ subject_data.append(values)
+ subject_ids.append(subject)
+ auces.append(Auce(
+ group if group is not None else 'All',
+ subject_ids, concentrations,
+ subject_times, subject_data
+ ))
+
+ serializers = [AuceSerializer(auce) for auce in auces]
+
+ if errors:
+ return Response(
+ errors, status=status.HTTP_400_BAD_REQUEST
+ )
+
+ return Response([serializer.data for serializer in serializers])
diff --git a/pkpdapp/pkpdapp/api/views/biomarker_type.py b/pkpdapp/pkpdapp/api/views/biomarker_type.py
new file mode 100644
index 00000000..0ac378d4
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/biomarker_type.py
@@ -0,0 +1,21 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+
+from pkpdapp.api.serializers import BiomarkerTypeSerializer
+from pkpdapp.api.views import ProjectFilter
+from pkpdapp.api.views import CheckAccessToProject
+from pkpdapp.models import BiomarkerType
+
+
+class BiomarkerTypeView(viewsets.ModelViewSet):
+ queryset = BiomarkerType.objects.all()
+ serializer_class = BiomarkerTypeSerializer
+ filter_backends = [ProjectFilter]
+ permission_classes = [
+ IsAuthenticated & CheckAccessToProject
+ ]
diff --git a/pkpdapp/pkpdapp/api/views/compound.py b/pkpdapp/pkpdapp/api/views/compound.py
new file mode 100644
index 00000000..b9b2cfac
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/compound.py
@@ -0,0 +1,20 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from pkpdapp.api.serializers import CompoundSerializer
+from pkpdapp.models import Compound
+from pkpdapp.api.views import (
+ CheckAccessToProject
+)
+from rest_framework.permissions import IsAuthenticated
+
+
+class CompoundView(viewsets.ModelViewSet):
+ queryset = Compound.objects.all()
+ serializer_class = CompoundSerializer
+ permission_classes = [
+ IsAuthenticated & CheckAccessToProject
+ ]
diff --git a/pkpdapp/pkpdapp/api/views/dataset.py b/pkpdapp/pkpdapp/api/views/dataset.py
new file mode 100644
index 00000000..74b31e9c
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/dataset.py
@@ -0,0 +1,38 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import (
+ viewsets, decorators, parsers, response, status
+)
+from pkpdapp.api.views import (
+ ProjectFilter,
+)
+from pkpdapp.api.serializers import (
+ DatasetSerializer, DatasetCsvSerializer
+)
+from pkpdapp.models import Dataset
+
+
+class DatasetView(viewsets.ModelViewSet):
+ queryset = Dataset.objects.all()
+ serializer_class = DatasetSerializer
+ filter_backends = [ProjectFilter]
+
+ @decorators.action(
+ detail=True,
+ serializer_class=DatasetCsvSerializer,
+ methods=['PUT'],
+ parser_classes=[parsers.MultiPartParser],
+ )
+ def csv(self, request, pk):
+ obj = self.get_object()
+ serializer = self.serializer_class(obj, data=request.data,
+ partial=True)
+ if serializer.is_valid():
+ serializer.save()
+ dataset_serializer = DatasetSerializer(obj)
+ return response.Response(dataset_serializer.data)
+ return response.Response(serializer.errors,
+ status.HTTP_400_BAD_REQUEST)
diff --git a/pkpdapp/pkpdapp/api/views/dose.py b/pkpdapp/pkpdapp/api/views/dose.py
new file mode 100644
index 00000000..8d7a774e
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/dose.py
@@ -0,0 +1,21 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+from pkpdapp.api.views import (
+ NotADatasetDose,
+ CheckAccessToProject,
+)
+from pkpdapp.api.serializers import DoseSerializer
+from pkpdapp.models import Dose
+
+
+class DoseView(viewsets.ModelViewSet):
+ queryset = Dose.objects.all()
+ serializer_class = DoseSerializer
+ permission_classes = [
+ IsAuthenticated & NotADatasetDose & CheckAccessToProject
+ ]
diff --git a/pkpdapp/pkpdapp/api/views/efficacy_experiment.py b/pkpdapp/pkpdapp/api/views/efficacy_experiment.py
new file mode 100644
index 00000000..9b89074c
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/efficacy_experiment.py
@@ -0,0 +1,21 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+from pkpdapp.api.views import (
+ NotADatasetDose,
+ CheckAccessToProject,
+)
+from pkpdapp.api.serializers import EfficacySerializer
+from pkpdapp.models import EfficacyExperiment
+
+
+class DoseView(viewsets.ModelViewSet):
+ queryset = EfficacyExperiment.objects.all()
+ serializer_class = EfficacySerializer
+ permission_classes = [
+ IsAuthenticated & NotADatasetDose & CheckAccessToProject
+ ]
diff --git a/pkpdapp/pkpdapp/api/views/filters.py b/pkpdapp/pkpdapp/api/views/filters.py
new file mode 100644
index 00000000..1d6193a5
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/filters.py
@@ -0,0 +1,178 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import (
+ filters
+)
+from django.db.models import Q
+
+from pkpdapp.models import (
+ Dataset, Project,
+ PharmacodynamicModel,
+ CombinedModel,
+ Protocol,
+ Unit,
+ BiomarkerType,
+ Variable,
+ Subject,
+ Inference, InferenceChain,
+ LogLikelihood,
+ Simulation,
+)
+
+
+class UserAccessFilter(filters.BaseFilterBackend):
+ """
+ Filter that allows filtering by user.
+ """
+
+ def filter_queryset(self, request, queryset, view):
+ if request.user.is_superuser:
+ return queryset
+
+ user = request.user
+ if queryset.model == Project:
+ queryset = queryset.filter(users=user)
+ else:
+ raise RuntimeError('queryset model {} not recognised')
+ return queryset
+
+
+class DosedPkModelFilter(filters.BaseFilterBackend):
+ """
+ Filter that only allows users to filter by dosed_pk_model.
+ """
+
+ def filter_queryset(self, request, queryset, view):
+ dosed_pk_model_id = \
+ request.query_params.get('dosed_pk_model_id')
+ if dosed_pk_model_id is not None:
+ try:
+ dosed_pk_model = CombinedModel.objects.get(
+ id=dosed_pk_model_id
+ )
+ if queryset.model == Variable:
+ queryset = dosed_pk_model.variables.all()
+ elif queryset.model == Unit:
+ unit_ids = (
+ dosed_pk_model.variables
+ .values_list('unit', flat=True)
+ )
+ queryset = Unit.objects.filter(id__in=unit_ids)
+ else:
+ raise RuntimeError('queryset model {} not recognised')
+ except CombinedModel.DoesNotExist:
+ queryset = queryset.model.objects.none()
+
+ return queryset
+
+
+class PdModelFilter(filters.BaseFilterBackend):
+ """
+ Filter that only allows users to filter by dosed_pk_model.
+ """
+
+ def filter_queryset(self, request, queryset, view):
+ pd_model_id = \
+ request.query_params.get('pd_model_id')
+ if pd_model_id is not None:
+ try:
+ pd_model = PharmacodynamicModel.objects.get(
+ id=pd_model_id
+ )
+ if queryset.model == Variable:
+ queryset = pd_model.variables.all()
+ elif queryset.model == Unit:
+ unit_ids = (
+ pd_model.variables
+ .values_list('unit', flat=True)
+ )
+ queryset = Unit.objects.filter(id__in=unit_ids)
+ else:
+ raise RuntimeError('queryset model {} not recognised')
+ except PharmacodynamicModel.DoesNotExist:
+ queryset = queryset.model.objects.none()
+
+ return queryset
+
+
+class InferenceFilter(filters.BaseFilterBackend):
+ """
+ Filter that only allows users to filter by inference.
+ """
+
+ def filter_queryset(self, request, queryset, view):
+ inference_id = \
+ request.query_params.get('inference_id')
+ if inference_id is not None:
+ try:
+ inference = Inference.objects.get(
+ id=inference_id
+ )
+ if queryset.model == Variable:
+ model = inference.get_model()
+ if model:
+ queryset = model.variables.all()
+ else:
+ queryset = queryset.model.objects.none()
+ elif queryset.model == InferenceChain:
+ queryset = inference.chains.all()
+ elif queryset.model == LogLikelihood:
+ queryset = inference.log_likelihoods.all()
+ else:
+ raise RuntimeError('queryset model {} not recognised')
+ except Inference.DoesNotExist:
+ queryset = queryset.model.objects.none()
+
+ return queryset
+
+
+class ProjectFilter(filters.BaseFilterBackend):
+ """
+ Filter that only allows users to filter by project.
+ """
+
+ def filter_queryset(self, request, queryset, view):
+ project_id = request.query_params.get('project_id')
+ if project_id is not None:
+ try:
+ project = Project.objects.get(
+ id=project_id
+ )
+ if queryset.model == Dataset:
+ queryset = project.datasets
+ elif queryset.model == Simulation:
+ queryset = project.simulations
+ elif queryset.model == PharmacodynamicModel:
+ queryset = project.pd_models
+ elif queryset.model == CombinedModel:
+ queryset = project.pk_models
+ elif queryset.model == Protocol:
+ queryset = project.protocols
+ elif queryset.model == Inference:
+ queryset = project.inference_set
+ elif queryset.model == InferenceChain:
+ queryset = InferenceChain.objects.filter(
+ inference__in=project.inference_set.all()
+ )
+ elif queryset.model == BiomarkerType:
+ queryset = BiomarkerType.objects.filter(
+ dataset__project=project
+ )
+ elif queryset.model == Subject:
+ queryset = Subject.objects.filter(
+ dataset__project=project
+ )
+ elif queryset.model == Variable:
+ queryset = queryset.filter(
+ Q(pd_model__project=project) |
+ Q(dosed_pk_model__project=project)
+ )
+ else:
+ raise RuntimeError('queryset model {} not recognised')
+ except Project.DoesNotExist:
+ queryset = queryset.model.objects.none()
+
+ return queryset
diff --git a/pkpdapp/pkpdapp/api/views/inference.py b/pkpdapp/pkpdapp/api/views/inference.py
new file mode 100644
index 00000000..ea4e16bd
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/inference.py
@@ -0,0 +1,731 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import numbers
+import re
+
+from pyparsing import ParseException
+from rest_framework import status, views, viewsets
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+
+from pkpdapp.api.serializers import (
+ AlgorithmSerializer,
+ InferenceChainSerializer,
+ InferenceSerializer,
+)
+from pkpdapp.api.views import (
+ InferenceFilter, ProjectFilter,
+ CheckAccessToProject
+)
+from pkpdapp.models import (
+ Algorithm,
+ BiomarkerType,
+ Dataset,
+ CombinedModel,
+ Inference,
+ InferenceChain,
+ LogLikelihood,
+ LogLikelihoodParameter,
+ Project,
+ Protocol,
+)
+from pkpdapp.utils import ExpressionParser
+
+
+class AlgorithmView(viewsets.ModelViewSet):
+ queryset = Algorithm.objects.all()
+ serializer_class = AlgorithmSerializer
+
+
+class InferenceView(viewsets.ModelViewSet):
+ queryset = Inference.objects.all()
+ serializer_class = InferenceSerializer
+ filter_backends = [ProjectFilter]
+ permission_classes = [
+ IsAuthenticated & CheckAccessToProject
+ ]
+
+ def delete(self, request, pk, format=None):
+ print('delete inference', pk)
+ inference = self.get_object(pk)
+ print('got inference', inference)
+ inference.delete()
+ print('deleted it')
+ return Response(status=status.HTTP_204_NO_CONTENT)
+
+ def destroy(self, request, *args, **kwargs):
+ print('destroy inference')
+ instance = self.get_object()
+ print('got inference', instance)
+ self.perform_destroy(instance)
+ print('deleted it')
+ return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class InferenceWizardView(views.APIView):
+ """
+ expecting data in the form:
+ {
+
+ # Inference parameters
+ 'id': 1
+ 'name': "my inference run",
+ 'project': 1,
+ 'algorithm': 2,
+ 'initialization_strategy': 'R',
+ 'initialization_inference': 2,
+ 'number_of_chains': 4,
+ 'max_number_of_iterations': 3000,
+ 'burn_in': 0,
+
+ # Model
+ 'model': {
+ 'form': 'PK',
+ 'id': 5
+ }
+ 'dataset': 3,
+
+ # Model parameters
+ 'parameters': [
+ {
+ 'name': 'myokit.parameter1'
+ 'form': 'N',
+ 'pooled': False,
+ 'parameters': [
+ '2 * biomarker[subject_weight]',
+ 'parameter[parameter1_variance]'
+ ]
+ },
+ {
+ 'name': 'parameter1_variance'
+ 'form': 'N',
+ 'parameters': [0, 1]
+ },
+ {
+ 'name': 'myokit.parameter2'
+ 'form': 'U',
+ 'parameters': [-1, 1]
+ },
+ {
+ 'name': 'myokit.parameter3'
+ 'form': 'F',
+ 'parameters': [123.5]
+ },
+ ]
+
+ # output
+ 'observations': [
+ {
+ 'model': 'myokit.plasma_concentration',
+ 'biomarker': 'concentration,
+ 'noise_form': 'N',
+ 'noise_param_form': 'N',
+ 'parameters': [0, 1]
+ },
+ {
+ 'model': 'myokit.bacteria_count',
+ 'biomarker': 'bacteria,
+ 'noise_form': 'LN',
+ 'noise_param_form': 'F'
+ 'parameters': [123.3]
+ },
+ ]
+ }
+
+ Uses model as the base model. If it is a PK or PKPD model, creates a model
+ for each protocol used in the dataset, replacing the protocol of the model
+ with each new one.
+
+ This set of models has a set of parameters. If pooled is True or not given,
+ then parameters of the same qname are assumed to be identical, if pooled is
+ False, then the value of this parameter is different across each subject.
+ All Variable fields from the original model are copied over to the new
+ models. Priors and fixed values for each parameter in this set are provided
+ in 'parameters'. Distribution parameters for each prior can be provided
+ using a python expression, or a number. If a python expression is used, the
+ keywords Parameter[] are used to refer to other parameters in
+ the list. Additional parameters can be added to the list (parameters not in
+ the model) to contruct hierarchical inference. You can refer to biomarkers
+ in the expression using the keyword Biomarker[].
+
+ The 'observations' field maps model output variables with biomarkers in the
+ dataset
+
+
+ """
+
+ @staticmethod
+ def _create_dosed_model(model, protocol, rename_model=False):
+ if model.pd_model is None:
+ stored_pd_model = None
+ else:
+ stored_pd_model = model.pd_model.create_stored_model()
+ stored_model = model.create_stored_model(
+ new_pd_model=stored_pd_model
+ )
+ if rename_model:
+ stored_model.name = model.name + '_' + protocol.name
+ stored_model.protocol = protocol
+
+ # make the model updatable in case protocol change results
+ # in new variables (i.e. D <-> I)
+ stored_model.read_only = False
+ stored_model.save()
+
+ # make it non-updatable again
+ stored_model.read_only = True
+ stored_model.save()
+
+ return stored_model
+
+ @staticmethod
+ def _create_subject_model(model, subject):
+ model_copy = type(model).objects.get(id=model.id)
+ original_name = model_copy.name
+ model_copy.id = None
+ model_copy.pk = None
+ model_copy.name = (
+ '{}_Subject{}'.format(original_name, subject.id_in_dataset)
+ )
+ model_copy.protocol = subject.protocol
+ model_copy.save()
+ stored_model = model_copy.create_stored_model()
+ model_copy.delete()
+ return stored_model
+
+ @staticmethod
+ def _set_observed_loglikelihoods(
+ obs, models, dataset, inference, protocols,
+ ):
+ # create noise param models
+ sigma_models = []
+ for ob in obs:
+ # create model
+ sigma_form = ob['noise_param_form']
+ parameters = ob['parameters']
+ name = 'sigma for {}'.format(
+ ob['model']
+ )
+ if sigma_form == LogLikelihood.Form.FIXED:
+ ll = LogLikelihood.objects.create(
+ inference=inference,
+ name=name,
+ form=sigma_form,
+ value=parameters[0]
+ )
+ else:
+ ll = LogLikelihood.objects.create(
+ inference=inference,
+ name=name,
+ form=sigma_form,
+ )
+ for p, v in zip(
+ ll.get_noise_log_likelihoods(),
+ parameters
+ ):
+ p.value = v
+ p.save()
+
+ sigma_models.append(ll)
+
+ output_names = [ob['model'] for ob in obs]
+ output_forms = [ob['noise_form'] for ob in obs]
+ biomarkers = []
+ for ob in obs:
+ try:
+ biomarker = BiomarkerType.objects.get(
+ name=ob['biomarker'], dataset=dataset
+ )
+ except BiomarkerType.DoesNotExist:
+ biomarker = None
+ biomarkers.append(biomarker)
+
+ print('found biomarkers', biomarkers)
+
+ for model, protocol in zip(models, protocols):
+ # remove all outputs (and their parameters)
+ # except those in output_names
+ # and set the right biomarkers and protocol
+ for output in model.outputs.all():
+ try:
+ index = output_names.index(output.variable.qname)
+ except ValueError:
+ index = None
+ if index is not None:
+ parent = output.parent
+ if protocol is not None:
+ parent.name = '{} ({})'.format(
+ parent.name, protocol.name
+ )
+ parent.biomarker_type = biomarkers[index]
+ print('setting biomarker', biomarkers[index],
+ biomarkers[index].name)
+ parent.observed = True
+ parent.protocol_filter = protocol
+ parent.form = output_forms[index]
+ parent.save()
+
+ # check there is actually data for this output
+ values, _, _ = parent.get_data()
+ if values is None:
+ # no data, delete this output as well
+ for param in parent.parameters.all():
+ if param != output:
+ param.child.delete()
+ parent.delete()
+ else:
+ # remove sigma param and replace it with generated one
+ parent.get_noise_log_likelihoods()[1].delete()
+ param = LogLikelihoodParameter.objects.create(
+ parent=parent, child=sigma_models[index],
+ parent_index=1,
+ name='sigma for ' + output.variable.qname
+ )
+ else:
+ for param in output.parent.parameters.all():
+ if param != output:
+ param.child.delete()
+ output.parent.delete()
+ return biomarkers
+
+ @staticmethod
+ def _set_parameters(
+ params, models, inference, dataset, observed_biomarkers
+ ):
+ created_params = {}
+ params_names = [p['name'] for p in params]
+ parser = ExpressionParser()
+ for model in models:
+ for model_param in model.parameters.all():
+ # if we've already done this param, use the child
+ if model_param.name in created_params:
+ # in pooled_params
+ old_child = model_param.child
+ model_param.child = created_params[model_param.name]
+ model_param.save()
+ old_child.delete()
+ continue
+
+ # else we'll deal with it now
+ # if the user has set a form for this param use it,
+ # otherwise use the default
+ try:
+ param_index = params_names.index(model_param.name)
+ except ValueError:
+ param_index = None
+ child = model_param.child
+ if param_index is not None:
+ param_info = params[param_index]
+
+ InferenceWizardView.param_info_to_log_likelihood(
+ child, param_info, params, parser, dataset, inference,
+ observed_biomarkers
+ )
+
+ created_params[model_param.name] = child
+
+ @staticmethod
+ def param_info_to_log_likelihood(
+ log_likelihood, param_info, params_info, parser, dataset, inference,
+ observed_biomarkers
+ ):
+ # deal with possible equations in noise params
+ # if form is fixed and there is an equation, the child form
+ # will be an equation
+ # if form is a distribution, then the child form will be
+ # that distribution, but if a parameter is given by an
+ # equation its child will be an equation
+ noise_params = param_info['parameters']
+ param_form = param_info['form']
+ pooled = param_info.get('pooled', True)
+ log_likelihood.form = param_form
+ log_likelihood.pooled = pooled
+
+ biomarker_type = None
+ if param_form == 'F' and isinstance(noise_params[0], str):
+ try:
+ log_likelihood.value = float(noise_params[0])
+ except ValueError:
+ biomarker_type = \
+ InferenceWizardView.to_equation_log_likelihood(
+ log_likelihood, noise_params[0], params_info,
+ parser, dataset, inference, observed_biomarkers
+ )
+ elif param_form == 'F':
+ log_likelihood.value = noise_params[0]
+ else:
+ log_likelihood.value = None
+
+ # if we're not pooled then need to give a biomarker_type to get list of
+ # subjects if there is a biomarker covariate in the children use that,
+ # otherwise use the list of subjects in the measured data
+ if not pooled:
+ if biomarker_type is None and observed_biomarkers:
+ if len(observed_biomarkers) == 0:
+ raise RuntimeError('no observed biomakers found')
+
+ # TODO: assumes that multiple observed biomarkers have
+ # identical subjects
+ log_likelihood.biomarker_type = observed_biomarkers[0]
+ log_likelihood.time_independent_data = True
+ else:
+ log_likelihood.biomarker_type = biomarker_type
+ log_likelihood.time_independent_data = True
+
+ log_likelihood.save()
+
+ # set length of output appropriately if not pooled
+ if not pooled:
+ _, _, subjects = log_likelihood.get_data()
+ output = log_likelihood.outputs.first()
+ output.length = len(subjects)
+ output.save()
+
+ for i, p in enumerate(log_likelihood.parameters.all()):
+ param_index = p.parent_index
+ if isinstance(noise_params[param_index], str):
+ try:
+ p.child.value = float(noise_params[param_index])
+ except ValueError:
+ InferenceWizardView.to_equation_log_likelihood(
+ p.child, noise_params[param_index], params_info,
+ parser, dataset, inference, observed_biomarkers
+ )
+ else:
+ p.child.value = noise_params[param_index]
+ p.child.save()
+
+ @staticmethod
+ def to_equation_log_likelihood(
+ log_likelihood, eqn_str, params_info, parser, dataset, inference,
+ observed_biomarkers
+ ):
+ # set form to equation and remove existing children
+ log_likelihood.children.clear()
+ log_likelihood.form = LogLikelihood.Form.EQUATION
+
+ params_in_eqn_str = parser.get_params(eqn_str)
+
+ # replace parameters and biomarkers in equation string
+ # with arg1, arg2 etc
+ escape_regex = re.compile(r'/[.*+?^${}()|[\]\\]/g')
+ for i, param in enumerate(params_in_eqn_str):
+ param1_escaped = escape_regex.sub(r'\\$&', param[1])
+ eqn_str = re.sub(
+ r'{}\s*\(\s*"{}"\s*\)'.format(param[0], param1_escaped),
+ r'arg{}'.format(i),
+ eqn_str
+ )
+ log_likelihood.description = eqn_str
+ log_likelihood.save()
+
+ # create children using parameters and biomarkers
+ biomarker_type = None
+ for i, param in enumerate(params_in_eqn_str):
+ if param[0] == 'parameter':
+ param_info = [
+ p for p in params_info
+ if p['name'] == param[1]
+ ][0]
+ new_child = LogLikelihood.objects.create(
+ name=param_info['name'],
+ form=LogLikelihood.Form.FIXED,
+ inference=inference,
+ value=0.0
+ )
+ InferenceWizardView.param_info_to_log_likelihood(
+ new_child, param_info, params_info, parser,
+ dataset, inference,
+ observed_biomarkers
+ )
+
+ elif param[0] == 'biomarker':
+ biomarker_type = BiomarkerType.objects.get(
+ name=param[1], dataset=dataset
+ )
+ new_child = LogLikelihood.objects.create(
+ name=param[1],
+ form=LogLikelihood.Form.FIXED,
+ biomarker_type=biomarker_type,
+ inference=inference,
+ )
+ LogLikelihoodParameter.objects.create(
+ parent=log_likelihood,
+ child=new_child,
+ parent_index=i,
+ name=param[1]
+ )
+ return biomarker_type
+
+ def post(self, request, format=None):
+ errors = {}
+ data = request.data
+ print('got data', data)
+
+ if 'project' in data:
+ try:
+ project = Project.objects.get(id=data['project'])
+ except Project.DoesNotExist:
+ errors['project'] = 'id {} not found'.format(data['project'])
+ else:
+ errors['project'] = 'field required'
+
+ if 'algorithm' in data:
+ try:
+ algorithm = Algorithm.objects.get(id=data['algorithm'])
+ except Algorithm.DoesNotExist:
+ errors['algorithm'] = 'id {} not found'.format(
+ data['algorithm'])
+ else:
+ algorithm = None
+
+ if 'dataset' in data:
+ try:
+ dataset = Dataset.objects.get(id=data['dataset'])
+ except Dataset.DoesNotExist:
+ errors['dataset'] = 'id {} not found'.format(data['dataset'])
+ else:
+ errors['dataset'] = 'field required'
+
+ model_table = None
+ model_id = None
+ if 'model' in data:
+ if 'form' in data['model']:
+ model_table = CombinedModel
+ else:
+ errors.get('model', {})['form'] = 'field required'
+ if 'id' in data['model']:
+ model_id = data['model']['id']
+ else:
+ errors.get('model', {})['id'] = 'field required'
+ else:
+ errors['model'] = 'field required'
+
+ if (
+ model_table is not None and
+ model_id is not None
+ ):
+ try:
+ model = model_table.objects.get(id=model_id)
+ except model_table.DoesNotExist:
+ model = None
+ errors['model'] = '{} id {} not found'.format(
+ model_table, model_id
+ )
+
+ parameter_errors = []
+ if 'parameters' in data:
+ parser = ExpressionParser()
+ param_names = [p['name'] for p in data['parameters']]
+ for i, param in enumerate(data['parameters']):
+ for j, dist_param in enumerate(param['parameters']):
+ if not isinstance(dist_param, (numbers.Number, str)):
+ parameter_errors.append((
+ (i, 'parameters', j),
+ 'should be str or number'
+ ))
+ elif isinstance(dist_param, str):
+ try:
+ parser.parse(dist_param)
+ params = parser.get_params(dist_param)
+ for param in params:
+ if (
+ param[0] == 'parameter' and
+ param[1] not in param_names
+ ):
+ parameter_errors.append((
+ (i, 'parameters', j),
+ '{} not in list of parameters'
+ .format(param[1])
+ ))
+ elif (
+ param[0] == 'biomarker' and
+ dataset.biomarker_types.filter(
+ name=param[1]
+ ).count() == 0
+ ):
+ parameter_errors.append((
+ (i, 'parameters', j),
+ '{} not in list of biomarkers'
+ .format(param[1])
+ ))
+ except ParseException as pe:
+ parameter_errors.append((
+ (i, 'parameters', j), str(pe)
+ ))
+ else:
+ errors['parameters'] = 'field required'
+
+ # fill out the errors with the parameter errors
+ for p in parameter_errors:
+ this_error = errors.get('parameters')
+ if this_error is None:
+ errors['parameters'] = {}
+ this_error = errors['parameters']
+ for index in p[0][:-1]:
+ new_error = this_error.get(index)
+ if new_error is None:
+ this_error[index] = {}
+ this_error = this_error[index]
+ else:
+ this_error = new_error
+ this_error[p[0][-1]] = p[1]
+
+ if 'observations' in data:
+ for i, obs in enumerate(data['observations']):
+ model_var = obs['model']
+ biomarker = obs['biomarker']
+ if dataset is not None and biomarker:
+ if dataset.biomarker_types.filter(
+ name=biomarker
+ ).count() == 0:
+ base_error = errors.get('observations', None)
+ if base_error is None:
+ errors['observations'] = {}
+ base_error = errors['observations']
+ error = base_error.get(i, None)
+ if error is None:
+ base_error[i] = {}
+ error = base_error[i]
+ error['biomarker'] = 'not found in dataset'
+ if model is not None:
+ if model.variables.filter(qname=model_var).count() == 0:
+ base_error = errors.get('observations', None)
+ if base_error is None:
+ errors['observations'] = {}
+ base_error = errors['observations']
+ error = base_error.get(i, None)
+ if error is None:
+ base_error[i] = {}
+ error = base_error[i]
+ error['model'] = 'not found in model'
+ else:
+ errors['observations'] = 'field required'
+
+ if errors:
+ return Response(errors, status=status.HTTP_400_BAD_REQUEST)
+
+ # create necessary models, one for each protocol
+ protocols = [
+ Protocol.objects.get(pk=p['protocol'])
+ for p in dataset.subjects.values('protocol').distinct()
+ if p['protocol'] is not None
+ ]
+ rename_models = len(protocols) > 1
+ if len(protocols) == 0 or data['model']['form'] == 'PD':
+ models = [model.create_stored_model()]
+ protocols = [None]
+ else:
+ models = [
+ self._create_dosed_model(
+ model, p, rename_model=rename_models)
+ for p in protocols
+ ]
+
+ # start creating inference object
+ initialization_inference = data.get('initialization_inference')
+ if initialization_inference is not None:
+ initialization_inference = Inference.objects.get(
+ id=initialization_inference
+ )
+
+ if 'id' in data:
+ inference = Inference.objects.get(id=data['id'])
+ inference.reset()
+ inference.name = data.get('name')
+ inference.project = project
+ inference.algorithm = algorithm
+ inference.initialization_strategy = \
+ data.get('initialization_strategy')
+ inference.initialization_inference = initialization_inference
+ inference.number_of_chains = data.get('number_of_chains')
+ inference.max_number_of_iterations = \
+ data.get('max_number_of_iterations')
+ inference.burn_in = data.get('burn_in')
+ inference.read_only = True
+ else:
+ inference = Inference.objects.create(
+ name=data.get('name'),
+ project=project,
+ algorithm=algorithm,
+ initialization_strategy=data.get('initialization_strategy'),
+ initialization_inference=initialization_inference,
+ number_of_chains=data.get('number_of_chains'),
+ max_number_of_iterations=data.get('max_number_of_iterations'),
+ burn_in=data.get('burn_in'),
+ read_only=True
+ )
+ data['id'] = inference.id
+
+ inference.metadata = data
+ inference.save()
+
+ model_loglikelihoods = [
+ LogLikelihood.objects.create(
+ variable=m.variables.first(),
+ inference=inference,
+ form=LogLikelihood.Form.MODEL
+ ) for m in models
+ ]
+
+ biomarkers = self._set_observed_loglikelihoods(
+ data['observations'], model_loglikelihoods,
+ dataset, inference, protocols
+ )
+
+ self._set_parameters(
+ data['parameters'], model_loglikelihoods, inference, dataset,
+ biomarkers
+ )
+
+ inference.run_inference()
+
+ return Response(InferenceSerializer(inference).data)
+
+
+class InferenceOperationView(views.APIView):
+ def op(self, inference):
+ raise NotImplementedError
+
+ def post(self, request, pk, format=None):
+ try:
+ inference = Inference.objects.get(pk=pk)
+ except Inference.DoesNotExist:
+ return Response(status=status.HTTP_404_NOT_FOUND)
+
+ errors = {}
+ if inference.log_likelihoods.count() == 0:
+ errors['log_likelihoods'] = (
+ 'Inference must have at least one log_likelihood'
+ )
+ ll_names = [
+ ll.name for ll in inference.log_likelihoods.all()
+ ]
+ if len(set(ll_names)) < len(ll_names):
+ errors['log_likelihoods'] = (
+ 'inference has log-likelihoods '
+ 'with identical names! {}'
+ ).format(ll_names)
+
+ if errors:
+ return Response(
+ errors, status=status.HTTP_400_BAD_REQUEST
+ )
+
+ self.op(inference)
+
+ return Response(InferenceSerializer(inference).data)
+
+
+class StopInferenceView(InferenceOperationView):
+ def op(self, inference):
+ return inference.stop_inference()
+
+
+class InferenceChainView(viewsets.ModelViewSet):
+ queryset = InferenceChain.objects.all()
+ serializer_class = InferenceChainSerializer
+ filter_backends = [ProjectFilter, InferenceFilter]
diff --git a/pkpdapp/pkpdapp/api/views/likelihoods.py b/pkpdapp/pkpdapp/api/views/likelihoods.py
new file mode 100644
index 00000000..4aeffa1c
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/likelihoods.py
@@ -0,0 +1,39 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+from pkpdapp.api.views import (
+ InferenceFilter,
+ CheckAccessToProject,
+)
+from pkpdapp.api.serializers import (
+ LogLikelihoodParameterSerializer, LogLikelihoodSerializer
+)
+from pkpdapp.models import (
+ LogLikelihood, LogLikelihoodParameter
+)
+
+
+class LogLikelihoodView(viewsets.ModelViewSet):
+ queryset = LogLikelihood.objects.all()
+ serializer_class = LogLikelihoodSerializer
+ filter_backends = [
+ InferenceFilter
+ ]
+ permission_classes = [
+ IsAuthenticated & CheckAccessToProject
+ ]
+
+
+class LogLikelihoodParameterView(viewsets.ModelViewSet):
+ queryset = LogLikelihoodParameter.objects.all()
+ serializer_class = LogLikelihoodParameterSerializer
+ filter_backends = [
+ InferenceFilter
+ ]
+ permission_classes = [
+ IsAuthenticated & CheckAccessToProject
+ ]
diff --git a/pkpdapp/pkpdapp/api/views/login.py b/pkpdapp/pkpdapp/api/views/login.py
new file mode 100644
index 00000000..99e25299
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/login.py
@@ -0,0 +1,77 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import json
+
+from django.contrib.auth import authenticate, login, logout
+from django.http import JsonResponse
+from django.middleware.csrf import get_token
+from django.views.decorators.csrf import ensure_csrf_cookie
+from django.views.decorators.http import require_POST
+from rest_framework.authentication import (
+ SessionAuthentication, BasicAuthentication
+)
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.views import APIView
+from pkpdapp.api.serializers import UserSerializer
+
+
+def get_csrf(request):
+ response = JsonResponse({
+ 'X-CSRFToken': get_token(request),
+ 'detail': 'CSRF cookie set'
+ })
+ return response
+
+
+@ensure_csrf_cookie
+@require_POST
+def login_view(request):
+ data = json.loads(request.body)
+ username = data.get('username')
+ password = data.get('password')
+ if username is None or password is None:
+ return JsonResponse({
+ 'detail': 'Please provide username and password.'
+ }, status=400)
+
+ user = authenticate(username=username, password=password)
+ if user is None:
+ return JsonResponse({'detail': 'Invalid credentials.'}, status=400)
+
+ login(request, user)
+
+ return JsonResponse({
+ 'user': UserSerializer(user).data,
+ 'detail': 'Successfully logged in.'
+ })
+
+
+@ensure_csrf_cookie
+def logout_view(request):
+ if not request.user.is_authenticated:
+ return JsonResponse({'detail': 'You\'re not logged in.'}, status=400)
+
+ logout(request)
+ return JsonResponse({'detail': 'Successfully logged out.'})
+
+
+class SessionView(APIView):
+ authentication_classes = [SessionAuthentication, BasicAuthentication]
+ permission_classes = [IsAuthenticated]
+
+ @staticmethod
+ def get(request, format=None):
+ return JsonResponse({'isAuthenticated': True, 'user':
+ UserSerializer(request.user).data})
+
+
+class WhoAmIView(APIView):
+ authentication_classes = [SessionAuthentication, BasicAuthentication]
+ permission_classes = [IsAuthenticated]
+
+ @staticmethod
+ def get(request, format=None):
+ return JsonResponse({'user': request.user})
diff --git a/pkpdapp/pkpdapp/api/views/models.py b/pkpdapp/pkpdapp/api/views/models.py
new file mode 100644
index 00000000..41600985
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/models.py
@@ -0,0 +1,145 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets, response, parsers, status, decorators
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+from drf_spectacular.types import OpenApiTypes
+from rest_framework.permissions import IsAuthenticated
+
+from pkpdapp.api.serializers import (
+ PharmacokineticSerializer,
+ PharmacodynamicSerializer,
+ CombinedModelSerializer,
+ PharmacodynamicSbmlSerializer,
+)
+from pkpdapp.api.views import ProjectFilter, CheckAccessToProject
+from pkpdapp.models import (
+ PharmacokineticModel,
+ PharmacodynamicModel,
+ CombinedModel,
+ Inference,
+)
+
+
+class PharmacokineticView(viewsets.ModelViewSet):
+ queryset = PharmacokineticModel.objects.all()
+ serializer_class = PharmacokineticSerializer
+ permission_classes = [IsAuthenticated & CheckAccessToProject]
+
+
+class CombinedModelView(viewsets.ModelViewSet):
+ queryset = CombinedModel.objects.all()
+ serializer_class = CombinedModelSerializer
+ filter_backends = [ProjectFilter]
+ permission_classes = [IsAuthenticated & CheckAccessToProject]
+
+ @extend_schema(
+ parameters=[
+ OpenApiParameter(
+ name="project_id",
+ description="Filter results by project ID",
+ required=False,
+ type=OpenApiTypes.INT,
+ location=OpenApiParameter.QUERY,
+ ),
+ ],
+ )
+ def list(self, request, *args, **kwargs):
+ return super().list(request, *args, **kwargs)
+
+ @decorators.action(
+ detail=True,
+ methods=["PUT"],
+ serializer_class=CombinedModelSerializer,
+ )
+ def set_variables_from_inference(self, request, pk):
+ obj = self.get_object()
+ try:
+ inference = Inference.objects.get(id=request.data["inference_id"])
+ except Inference.DoesNotExist:
+ return response.Response(
+ {"inference_id": "inference not found"}, status.HTTP_400_BAD_REQUEST
+ )
+
+ obj.set_variables_from_inference(inference)
+ serializer = self.serializer_class(obj)
+ return response.Response(serializer.data)
+
+ @decorators.action(
+ detail=True,
+ methods=["PUT"],
+ serializer_class=CombinedModelSerializer,
+ )
+ def set_params_to_defaults(self, request, pk):
+ obj = self.get_object()
+ project = obj.get_project()
+ if project is None:
+ return response.Response(
+ {"project": "project not found"}, status.HTTP_400_BAD_REQUEST
+ )
+ compound = project.compound
+ if compound is None:
+ return response.Response(
+ {"compound": "compound not found"}, status.HTTP_400_BAD_REQUEST
+ )
+ print("setting params to defaults", project.species, compound.compound_type)
+ obj.reset_params_to_defaults(project.species, compound.compound_type)
+ serializer = self.serializer_class(obj)
+ return response.Response(serializer.data)
+
+
+class PharmacodynamicView(viewsets.ModelViewSet):
+ queryset = PharmacodynamicModel.objects.all()
+ serializer_class = PharmacodynamicSerializer
+ filter_backends = [ProjectFilter]
+ permission_classes = [IsAuthenticated & CheckAccessToProject]
+
+ @decorators.action(
+ detail=True,
+ methods=["PUT"],
+ serializer_class=PharmacodynamicSbmlSerializer,
+ parser_classes=[parsers.MultiPartParser],
+ )
+ def sbml(self, request, pk):
+ obj = self.get_object()
+ serializer = self.serializer_class(obj, data=request.data, partial=True)
+ if serializer.is_valid():
+ serializer.save()
+ return response.Response(serializer.data)
+ print("xXXXXXx", serializer.errors)
+ return response.Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
+
+ @decorators.action(
+ detail=True,
+ methods=["PUT"],
+ serializer_class=PharmacodynamicSerializer,
+ parser_classes=[parsers.MultiPartParser],
+ )
+ def mmt(self, request, pk):
+ obj = self.get_object()
+ serializer = self.serializer_class(obj, data=request.data, partial=True)
+ if serializer.is_valid():
+ serializer.save()
+ return response.Response(serializer.data)
+ return response.Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
+
+ @decorators.action(
+ detail=True,
+ methods=["PUT"],
+ serializer_class=PharmacodynamicSerializer,
+ )
+ def set_variables_from_inference(self, request, pk):
+ obj = self.get_object()
+ try:
+ print("got request", request.data)
+ inference = Inference.objects.get(id=request.data["inference_id"])
+ except Inference.DoesNotExist:
+ return response.Response(
+ {"inference_id": "inference not found"}, status.HTTP_400_BAD_REQUEST
+ )
+
+ obj.set_variables_from_inference(inference)
+ serializer = self.serializer_class(obj)
+ return response.Response(serializer.data)
diff --git a/pkpdapp/pkpdapp/api/views/nca.py b/pkpdapp/pkpdapp/api/views/nca.py
new file mode 100644
index 00000000..3c786f97
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/nca.py
@@ -0,0 +1,92 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import (
+ views, status
+)
+from rest_framework.response import Response
+from pkpdapp.models import (
+ BiomarkerType,
+ Subject,
+ Dose,
+)
+from pkpdapp.api.serializers import NcaSerializer
+from pkpdapp.utils import NCA
+
+
+class NcaView(views.APIView):
+ def post(self, request, format=None):
+ errors = {
+ }
+ subject_id = request.data.get('subject_id', None)
+ if subject_id is None:
+ errors['subject_id'] = "This field is required"
+ else:
+ try:
+ subject = Subject.objects.get(id=subject_id)
+ except Subject.DoesNotExist:
+ errors['subject_id'] = \
+ "Subject id {} not found".format(subject_id)
+ if not subject.protocol:
+ errors['subject_id'] = (
+ "Subject id {} does not have a protocol"
+ .format(subject_id)
+ )
+ if subject.protocol.dose_type != subject.protocol.DoseType.DIRECT:
+ errors['subject_id'] = \
+ "Subject dosing protocol is required to be type IV"
+
+ biomarker_type_id = request.data.get('biomarker_type_id', None)
+ if biomarker_type_id is None:
+ errors['biomarker_type_id'] = "This field is required"
+ else:
+ try:
+ biomarker_type = \
+ BiomarkerType.objects.get(id=biomarker_type_id)
+ except BiomarkerType.DoesNotExist:
+ errors['biomarker_type_id'] = (
+ "BiomarkerType id {} not found"
+ .format(biomarker_type_id)
+ )
+
+ if errors:
+ return Response(
+ errors, status=status.HTTP_400_BAD_REQUEST
+ )
+ protocol = subject.protocol
+ df = biomarker_type.data()
+ df = df.loc[df['subjects'] == subject.id]
+
+ if df.shape[0] == 0:
+ errors['biomarker_type'] = (
+ "BiomarkerType {} does not have measurements "
+ "for subject id {}."
+ .format(biomarker_type.id, subject.id)
+ )
+
+ doses = Dose.objects.filter(
+ protocol=protocol
+ ).all()
+
+ if len(doses) != 1:
+ errors['protocol_id'] = (
+ "Protocol id {} has {} doses, only a single dose. "
+ "Please choose a protocol with only one dose."
+ .format(protocol.id, len(doses))
+ )
+
+ if errors:
+ return Response(
+ errors, status=status.HTTP_400_BAD_REQUEST
+ )
+
+ times = df['times'].tolist()
+ concentrations = df['values'].tolist()
+ dose_amount = doses[0].amount
+
+ nca = NCA(times, concentrations, dose_amount)
+ nca.calculate_nca()
+ serializer = NcaSerializer(nca)
+ return Response(serializer.data)
diff --git a/pkpdapp/pkpdapp/api/views/permissions.py b/pkpdapp/pkpdapp/api/views/permissions.py
new file mode 100644
index 00000000..600f45ed
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/permissions.py
@@ -0,0 +1,93 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework.permissions import (
+ BasePermission
+)
+
+
+from pkpdapp.models import (
+ Project, ProjectAccess
+)
+
+
+class NotADatasetDose(BasePermission):
+ def has_object_permission(self, request, view, obj):
+ is_update_method = request.method == 'PUT' or request.method == 'PATCH'
+ if is_update_method and obj.protocol.get_dataset():
+ return False
+ return True
+
+
+class NotADatasetProtocol(BasePermission):
+ def has_object_permission(self, request, view, obj):
+ is_update_method = \
+ request.method == 'PUT' or request.method == 'PATCH'
+ if is_update_method and obj.get_dataset():
+ return False
+ return True
+
+
+class CheckAccessToProject(BasePermission):
+ def has_permission(self, request, view):
+ if request.user.is_superuser:
+ return True
+
+ is_create_method = (
+ request.method == 'POST'
+ )
+
+ if isinstance(request.data, list):
+ project_id = request.data[0].get('project', None)
+ else:
+ project_id = request.data.get('project', None)
+
+ if project_id is None:
+ return True
+
+ project = Project.objects.get(id=project_id)
+
+ if project is None:
+ return True
+
+ try:
+ access = ProjectAccess.objects.get(
+ project=project,
+ user=request.user,
+ )
+ except ProjectAccess.DoesNotExist:
+ return False
+
+ if is_create_method:
+ return not access.read_only
+
+ return True
+
+ def has_object_permission(self, request, view, obj):
+ if request.user.is_superuser:
+ return True
+
+ is_update_method = (
+ request.method == 'PUT' or
+ request.method == 'PATCH'
+ )
+
+ project = obj.get_project()
+
+ if project is None:
+ return True
+
+ try:
+ access = ProjectAccess.objects.get(
+ project=project,
+ user=request.user,
+ )
+ except ProjectAccess.DoesNotExist:
+ return False
+
+ if is_update_method:
+ return not access.read_only
+
+ return True
diff --git a/pkpdapp/pkpdapp/api/views/project.py b/pkpdapp/pkpdapp/api/views/project.py
new file mode 100644
index 00000000..503ca0b4
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/project.py
@@ -0,0 +1,61 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import (
+ viewsets, response, parsers, status, decorators
+)
+from rest_framework.permissions import IsAuthenticated
+
+from pkpdapp.api.serializers import (
+ ProjectSerializer,
+ ProjectAccessSerializer,
+ MonolixSerializer
+)
+from pkpdapp.api.views import (
+ UserAccessFilter,
+ CheckAccessToProject
+)
+from pkpdapp.models import (
+ Project,
+ ProjectAccess
+)
+
+
+class EnablePartialUpdateMixin:
+ """Enable partial updates"""
+
+ def update(self, request, *args, **kwargs):
+ kwargs['partial'] = True
+ return super().update(request, *args, **kwargs)
+
+
+class ProjectView(EnablePartialUpdateMixin, viewsets.ModelViewSet):
+ queryset = Project.objects.all()
+ serializer_class = ProjectSerializer
+ filter_backends = [UserAccessFilter]
+
+ @decorators.action(
+ detail=True,
+ methods=['PUT'],
+ serializer_class=MonolixSerializer,
+ parser_classes=[parsers.MultiPartParser],
+ )
+ def monolix(self, request, pk):
+ obj = self.get_object()
+ serializer = self.serializer_class(obj, data=request.data,
+ partial=True)
+ if serializer.is_valid():
+ serializer.save()
+ return response.Response(serializer.data)
+ return response.Response(serializer.errors,
+ status.HTTP_400_BAD_REQUEST)
+
+
+class ProjectAccessView(viewsets.ModelViewSet):
+ queryset = ProjectAccess.objects.all()
+ serializer_class = ProjectAccessSerializer
+ permission_classes = [
+ IsAuthenticated & CheckAccessToProject
+ ]
diff --git a/pkpdapp/pkpdapp/api/views/protocol.py b/pkpdapp/pkpdapp/api/views/protocol.py
new file mode 100644
index 00000000..4ed3b826
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/protocol.py
@@ -0,0 +1,39 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+from drf_spectacular.types import OpenApiTypes
+from pkpdapp.api.serializers import ProtocolSerializer
+from pkpdapp.api.views import (
+ ProjectFilter,
+ NotADatasetProtocol,
+ CheckAccessToProject
+)
+from pkpdapp.models import Protocol
+
+
+class ProtocolView(viewsets.ModelViewSet):
+ queryset = Protocol.objects.all()
+ serializer_class = ProtocolSerializer
+ filter_backends = [ProjectFilter]
+ permission_classes = [
+ IsAuthenticated & NotADatasetProtocol & CheckAccessToProject
+ ]
+
+ @extend_schema(
+ parameters=[
+ OpenApiParameter(
+ name='project_id',
+ description='Filter results by project ID',
+ required=False,
+ type=OpenApiTypes.INT,
+ location=OpenApiParameter.QUERY
+ ),
+ ],
+ )
+ def list(self, request, *args, **kwargs):
+ return super().list(request, *args, **kwargs)
diff --git a/pkpdapp/pkpdapp/api/views/simulate.py b/pkpdapp/pkpdapp/api/views/simulate.py
new file mode 100644
index 00000000..716dc1c7
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/simulate.py
@@ -0,0 +1,79 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import views, status
+from rest_framework.response import Response
+from rest_framework import serializers
+from drf_spectacular.utils import extend_schema
+import myokit
+from pkpdapp.models import (
+ CombinedModel, PharmacodynamicModel, Variable
+)
+
+
+class SimulateSerializer(serializers.Serializer):
+ outputs = serializers.ListField(child=serializers.CharField())
+ variables = serializers.DictField(child=serializers.FloatField())
+ time_max = serializers.FloatField(required=False)
+
+
+class SimulateResponseSerializer(serializers.Serializer):
+ time = serializers.ListField(child=serializers.FloatField())
+ outputs = serializers.DictField(
+ child=serializers.ListField(child=serializers.FloatField()))
+
+ def to_representation(self, instance):
+ outputs = {}
+ times = []
+ for var_id, values in instance.items():
+ variable = Variable.objects.get(pk=var_id)
+ if variable.name == 'time' or variable.name == 't':
+ times = values
+ outputs[var_id] = values
+ return {
+ 'outputs': outputs,
+ 'time': times,
+ }
+
+
+class ErrorResponseSerializer(serializers.Serializer):
+ error = serializers.CharField()
+
+
+@extend_schema(
+ request=SimulateSerializer,
+ responses={
+ 200: SimulateResponseSerializer,
+ 400: ErrorResponseSerializer,
+ 404: None,
+ },
+
+)
+class SimulateBaseView(views.APIView):
+ def post(self, request, pk, format=None):
+ try:
+ m = self.model.objects.get(pk=pk)
+ except self.model.DoesNotExist:
+ return Response(status=status.HTTP_404_NOT_FOUND)
+ outputs = request.data.get('outputs', None)
+ variables = request.data.get('variables', None)
+ time_max = request.data.get('time_max', None)
+ try:
+ result = m.simulate(outputs, variables, time_max)
+ except myokit.SimulationError as e:
+ serialized_result = ErrorResponseSerializer({'error': str(e)})
+ return Response(
+ serialized_result.data, status=status.HTTP_400_BAD_REQUEST
+ )
+ serialized_result = SimulateResponseSerializer(result)
+ return Response(serialized_result.data)
+
+
+class SimulateCombinedView(SimulateBaseView):
+ model = CombinedModel
+
+
+class SimulatePdView(SimulateBaseView):
+ model = PharmacodynamicModel
diff --git a/pkpdapp/pkpdapp/api/views/simulation.py b/pkpdapp/pkpdapp/api/views/simulation.py
new file mode 100644
index 00000000..6e3bb7f4
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/simulation.py
@@ -0,0 +1,42 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+from drf_spectacular.types import OpenApiTypes
+from pkpdapp.models import Simulation
+from pkpdapp.api.serializers import (
+ SimulationSerializer
+)
+from pkpdapp.api.views import (
+ ProjectFilter,
+ CheckAccessToProject
+)
+
+
+class SimulationViewSet(viewsets.ModelViewSet):
+ queryset = Simulation.objects.all()
+ serializer_class = SimulationSerializer
+ filter_backends = [ProjectFilter]
+ permission_classes = [
+ IsAuthenticated & CheckAccessToProject
+ ]
+
+ @extend_schema(
+ parameters=[
+ OpenApiParameter(
+ name='project_id',
+ description='Filter results by project ID',
+ required=False,
+ type=OpenApiTypes.INT,
+ location=OpenApiParameter.QUERY
+ ),
+ ],
+ )
+ def list(self, request, *args, **kwargs):
+ return super().list(request, *args, **kwargs)
diff --git a/pkpdapp/pkpdapp/api/views/subject.py b/pkpdapp/pkpdapp/api/views/subject.py
new file mode 100644
index 00000000..f7c0ce8c
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/subject.py
@@ -0,0 +1,17 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from pkpdapp.api.views import (
+ ProjectFilter,
+)
+from pkpdapp.api.serializers import SubjectSerializer
+from pkpdapp.models import Subject
+
+
+class SubjectView(viewsets.ModelViewSet):
+ queryset = Subject.objects.all()
+ serializer_class = SubjectSerializer
+ filter_backends = [ProjectFilter]
diff --git a/pkpdapp/pkpdapp/api/views/unit.py b/pkpdapp/pkpdapp/api/views/unit.py
new file mode 100644
index 00000000..af101503
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/unit.py
@@ -0,0 +1,69 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from pkpdapp.api.views import (
+ DosedPkModelFilter,
+ PdModelFilter,
+)
+from pkpdapp.api.serializers import UnitSerializer
+from pkpdapp.models import Unit, Compound
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+from drf_spectacular.types import OpenApiTypes
+
+
+class UnitView(viewsets.ModelViewSet):
+ queryset = Unit.objects.all()
+ serializer_class = UnitSerializer
+ filter_backends = [DosedPkModelFilter, PdModelFilter]
+
+ def get_serializer_context(self):
+ context = super().get_serializer_context()
+
+ request = self.request
+ compound_id = None
+ compound = None
+
+ if request is not None:
+ compound_id = self.request.query_params.get("compound_id")
+
+ if compound_id is not None:
+ try:
+ compound = Compound.objects.get(pk=compound_id)
+ except Compound.DoesNotExist:
+ pass
+
+ if compound is not None:
+ context["compound"] = compound
+
+ return context
+
+ @extend_schema(
+ parameters=[
+ OpenApiParameter(
+ name="compound_id",
+ description="Enable conversions based on compound information",
+ required=False,
+ type=OpenApiTypes.INT,
+ location=OpenApiParameter.QUERY,
+ ),
+ ],
+ )
+ def list(self, request, *args, **kwargs):
+ return super().list(request, *args, **kwargs)
+
+ @extend_schema(
+ parameters=[
+ OpenApiParameter(
+ name="compound_id",
+ description="Enable conversions based on compound information",
+ required=False,
+ type=OpenApiTypes.INT,
+ location=OpenApiParameter.QUERY,
+ ),
+ ],
+ )
+ def retrieve(self, request, *args, **kwargs):
+ return super().retrieve(request, *args, **kwargs)
diff --git a/pkpdapp/pkpdapp/api/views/user.py b/pkpdapp/pkpdapp/api/views/user.py
new file mode 100644
index 00000000..20b9124f
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/user.py
@@ -0,0 +1,13 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from django.contrib.auth.models import User
+from pkpdapp.api.serializers import UserSerializer
+
+
+class UserView(viewsets.ModelViewSet):
+ queryset = User.objects.all()
+ serializer_class = UserSerializer
diff --git a/pkpdapp/pkpdapp/api/views/variable.py b/pkpdapp/pkpdapp/api/views/variable.py
new file mode 100644
index 00000000..f6a989cd
--- /dev/null
+++ b/pkpdapp/pkpdapp/api/views/variable.py
@@ -0,0 +1,58 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+from drf_spectacular.types import OpenApiTypes
+from pkpdapp.api.views import (
+ ProjectFilter,
+ CheckAccessToProject,
+ DosedPkModelFilter,
+ PdModelFilter,
+)
+from pkpdapp.api.serializers import (
+ VariableSerializer
+)
+from pkpdapp.models import Variable
+
+
+class VariableView(viewsets.ModelViewSet):
+ queryset = Variable.objects.all()
+ serializer_class = VariableSerializer
+ filter_backends = [
+ ProjectFilter, DosedPkModelFilter, PdModelFilter
+ ]
+ permission_classes = [
+ IsAuthenticated & CheckAccessToProject
+ ]
+
+ @extend_schema(
+ parameters=[
+ OpenApiParameter(
+ name='project_id',
+ description='Filter results by project ID',
+ required=False,
+ type=OpenApiTypes.INT,
+ location=OpenApiParameter.QUERY
+ ),
+ OpenApiParameter(
+ name='dosed_pk_model_id',
+ description='Filter results by dosed_pk_model ID',
+ required=False,
+ type=OpenApiTypes.INT,
+ location=OpenApiParameter.QUERY
+ ),
+ OpenApiParameter(
+ name='pd_model_id',
+ description='Filter results by pd_model ID',
+ required=False,
+ type=OpenApiTypes.INT,
+ location=OpenApiParameter.QUERY
+ ),
+ ],
+ )
+ def list(self, request, *args, **kwargs):
+ return super().list(request, *args, **kwargs)
diff --git a/pkpdapp/pkpdapp/apps.py b/pkpdapp/pkpdapp/apps.py
new file mode 100644
index 00000000..a82f7331
--- /dev/null
+++ b/pkpdapp/pkpdapp/apps.py
@@ -0,0 +1,17 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.apps import AppConfig
+
+
+class PkpdAppConfig(AppConfig):
+ name = 'pkpdapp'
+
+ def ready(self):
+ from django.contrib.auth.models import User
+ from .signals import add_profile_on_user_save
+ from django.db.models.signals import post_save
+ post_save.connect(add_profile_on_user_save, sender=User)
diff --git a/pkpdapp/pkpdapp/asgi.py b/pkpdapp/pkpdapp/asgi.py
new file mode 100644
index 00000000..7f1ccf70
--- /dev/null
+++ b/pkpdapp/pkpdapp/asgi.py
@@ -0,0 +1,22 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+"""
+ASGI config for pkpdapp project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/howto/deployment/asgi/.
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'pkpdapp.settings')
+
+application = get_asgi_application()
diff --git a/pkpdapp/pkpdapp/celery.py b/pkpdapp/pkpdapp/celery.py
new file mode 100644
index 00000000..5b5eb8ad
--- /dev/null
+++ b/pkpdapp/pkpdapp/celery.py
@@ -0,0 +1,28 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import os
+
+from celery import Celery
+
+# Set the default Django settings module for the 'celery' program.
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'pkpdapp.settings')
+
+app = Celery('pkpdapp', backend='rpc://', broker='pyamqp://')
+
+# Using a string here means the worker doesn't have to serialize
+# the configuration object to child processes.
+# - namespace='CELERY' means all celery-related configuration keys
+# should have a `CELERY_` prefix.
+app.config_from_object('django.conf:settings', namespace='CELERY')
+
+# Load task modules from all registered Django apps.
+app.autodiscover_tasks()
+
+
+@app.task(bind=True)
+def debug_task(self):
+ print(f'Request: {self.request!r}')
diff --git a/pkpdapp/pkpdapp/dash_apps/auce_app.py b/pkpdapp/pkpdapp/dash_apps/auce_app.py
new file mode 100644
index 00000000..dd71d173
--- /dev/null
+++ b/pkpdapp/pkpdapp/dash_apps/auce_app.py
@@ -0,0 +1,189 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import dash_core_components as dcc
+import dash_html_components as html
+import dash_bootstrap_components as dbc
+from dash.dependencies import Input, Output
+import plotly.graph_objects as go
+from .auce_figure import AuceFigure
+import pandas as pd
+import django_plotly_dash as dpd
+import json
+
+# Create data view
+app = dpd.DjangoDash(
+ name='auce_view',
+ add_bootstrap_links=True
+)
+
+# Create dash app
+app.layout = dbc.Container([
+ dbc.Row(children=[
+ dbc.Col(width=5, children=[
+ html.Label("Select datasets to use:"),
+ dcc.Dropdown(
+ id='dataset-dropdown',
+ ),
+ ])
+ ]),
+ dbc.Row([
+ dbc.Col(
+ children=[
+ html.P(children=(
+ 'Note: AUCE app requries Dosing Groups corresponding to '
+ 'numerical concentrations '
+ )),
+ dbc.Col(width=3, children=[
+ html.Label("Choose variable:"),
+ dcc.Dropdown(
+ id='auce-biomarker-dropdown',
+ ),
+ ]),
+ dcc.Graph(
+ id='initial-doses-dashboard',
+ figure=go.Figure(),
+ style={'width': '100%'}
+ ),
+ dcc.Graph(
+ id='auce-dashboard',
+ figure=go.Figure(),
+ style={'width': '100%'}
+ )
+ ],
+ ),
+ ]),
+])
+
+
+def rehydrate_state(session_state):
+ if session_state is None:
+ raise NotImplementedError("Cannot handle a missing session state")
+
+ state = session_state.get('auce_view', None)
+
+ if state is None:
+ raise NotImplementedError('AuceState missing in session state')
+
+ return AuceState.from_json(state)
+
+
+@app.callback(
+ [
+ Output('dataset-dropdown', 'options'),
+ Output('dataset-dropdown', 'value'),
+ ],
+ [Input('auce-dashboard', 'style')],
+)
+def update_datasets(_, session_state=None):
+ state = rehydrate_state(session_state)
+ return state._dataset_options, state._selected_dataset
+
+
+@app.callback(
+ [
+ Output('auce-biomarker-dropdown', 'options'),
+ Output('auce-biomarker-dropdown', 'value'),
+ ],
+ [
+ Input('dataset-dropdown', 'value'),
+ ]
+)
+def update_nca_auce_options(dataset_dropdown, session_state=None):
+ state = rehydrate_state(session_state)
+ state._selected_dataset = dataset_dropdown
+ biomarkers = state._get_biomarkers()
+ return biomarkers, biomarkers[0]['value']
+
+
+@app.callback(
+ [
+ Output('initial-doses-dashboard', 'figure'),
+ Output('auce-dashboard', 'figure'),
+ ],
+ [
+ Input('auce-biomarker-dropdown', 'value'),
+ Input('dataset-dropdown', 'value'),
+ ],
+)
+def update_auce(auce_biomarker_dropdown, dataset_dropdown,
+ session_state=None):
+ state = rehydrate_state(session_state)
+ state._selected_dataset = dataset_dropdown
+ return state.generate_auce_figures(auce_biomarker_dropdown)
+
+
+class AuceState:
+ """
+ """
+ _id_key = 'ID'
+ _biomarker_key = 'Biomarker'
+ _compound_key = 'Compound'
+
+ def __init__(self):
+ self._selected_dataset = []
+ self._datasets = []
+ self._dataset_options = []
+ self._auce_biomarker = None
+
+ def add_datasets(self, datasets, dataset_names):
+ # handle empty datasets
+ if not datasets:
+ return
+
+ # by default show last datset
+ self._selected_dataset = 0
+ self._datasets = datasets
+ for dataset, dataset_name in zip(self._datasets, dataset_names):
+ dataset['Dataset'] = dataset_name
+ self._dataset_options = [
+ {'label': name, 'value': i} for i, name in enumerate(dataset_names)
+ ]
+
+ # by default use first biomarker
+ self._auce_biomarker = self._datasets[
+ self._selected_dataset
+ ][self._biomarker_key][0]
+
+ def to_json(self):
+ state_dict = {
+ '_selected_dataset': self._selected_dataset,
+ '_datasets': [d.to_dict() for d in self._datasets],
+ '_dataset_options': self._dataset_options,
+ '_auce_biomarker': self._auce_biomarker,
+ }
+ return json.dumps(state_dict)
+
+ @classmethod
+ def from_json(cls, j):
+ data_dict = json.loads(j)
+ o = cls()
+ o._selected_dataset = data_dict['_selected_dataset']
+ o._datasets = [
+ pd.DataFrame.from_dict(d) for d in data_dict['_datasets']
+ ]
+
+ o._dataset_options = data_dict['_dataset_options']
+ o._auce_biomarker = data_dict['_auce_biomarker']
+ return o
+
+ def generate_auce_figures(self, new_biomarker=None):
+ if not self._datasets:
+ return go.Figure(), go.Figure()
+ if new_biomarker:
+ self._auce_biomarker = new_biomarker
+ self._auce_figure = AuceFigure(
+ self._datasets[self._selected_dataset],
+ self._auce_biomarker
+ )
+ return self._auce_figure.figures()
+
+ def _get_biomarkers(self):
+ biomarkers = set()
+ biomarkers = self._datasets[self._selected_dataset][
+ self._biomarker_key
+ ].unique().tolist()
+ return [{'label': str(i), 'value': i} for i in biomarkers]
diff --git a/pkpdapp/pkpdapp/dash_apps/auce_figure.py b/pkpdapp/pkpdapp/dash_apps/auce_figure.py
new file mode 100644
index 00000000..3a63d8bd
--- /dev/null
+++ b/pkpdapp/pkpdapp/dash_apps/auce_figure.py
@@ -0,0 +1,430 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+'''
+Temporary demo.
+'''
+
+import numpy as np
+import plotly
+import plotly.colors
+import plotly.graph_objects as go
+from plotly.validators.scatter.marker import SymbolValidator
+from scipy.optimize import curve_fit
+
+
+colors = plotly.colors.qualitative.Plotly[:1000]
+symbols = SymbolValidator().values
+
+
+class modeling_class:
+ def __init__(self):
+ self.series = ""
+ self.auce = 0
+
+
+class AuceFigure():
+ """
+ """
+
+ def __init__(self, dataset, biomarker):
+
+ self._id_key = 'ID'
+ self._time_key = 'Time'
+ self._obs_type_key = 'Biomarker'
+ self._obs_key = 'Measurement'
+ self._dose_group_key = 'DoseGroup'
+ self._group_key = 'Group'
+
+ self._fig = go.Figure()
+ self._auce_vs_concentration_fig = go.Figure()
+ self._dataset = dataset
+ self._auce_fit_type = 'Sigmoid'
+ self._class1_selection = 'Biomarker'
+ self._class2_selection = 'Group'
+ self._class3_selection = None
+ self._class1_plot_selection = biomarker
+ self._class2_plot_selection = None
+ self._class3_plot_selection = None
+ self._concentration_plot_selection = None
+
+ self._auce_vs_concentration_fig = compute_auce_vs_concentration(
+ self._dataset, self._auce_vs_concentration_fig,
+ self._time_key, self._auce_fit_type, self._obs_key,
+ self._class1_selection,
+ self._dose_group_key, self._class2_selection,
+ self._class3_selection, self._class1_plot_selection,
+ self._class2_plot_selection, self._class3_plot_selection)
+
+ self._fig = update_figure(
+ self._dataset, self._fig,
+ self._time_key, self._obs_key, self._class1_selection,
+ self._dose_group_key, self._class2_selection,
+ self._class3_selection, self._class1_plot_selection,
+ self._concentration_plot_selection, self._class2_plot_selection,
+ self._class3_plot_selection
+ )
+
+ def figures(self):
+ return self._fig, self._auce_vs_concentration_fig
+
+
+def fsigmoid(concentration, top, bottom, EC50):
+ # this function simulates Emax-EC50 curve for a given concentration range
+ return bottom + concentration * (top - bottom) / (EC50 + concentration)
+
+
+def update_figure(dataset, fig, time_selection, y_selection, class1_selection,
+ concentration_selection, class2_selection,
+ class3_selection, class1_plot_selection,
+ concentration_plot_selection, class2_plot_selection,
+ class3_plot_selection):
+ fig.data = []
+
+ data = dataset.loc[dataset[class1_selection] == class1_plot_selection]
+
+ if concentration_plot_selection:
+ concentration = [concentration_plot_selection]
+ else:
+ concentration = data[concentration_selection].unique()
+
+ for index_concentration, concentration_selected in \
+ enumerate(concentration):
+
+ concentration_data = data.loc[
+ data[concentration_selection] == concentration_selected
+ ]
+ if class2_plot_selection:
+ class2 = [class2_plot_selection]
+ else:
+ class2 = concentration_data[class2_selection].unique()
+
+ for index_class2, class2_selected in enumerate(class2):
+
+ class2_data = concentration_data.loc[
+ concentration_data[class2_selection] == class2_selected
+ ]
+
+ if class3_plot_selection:
+ class3 = class2_data[class3_selection].unique()
+
+ for index_class3, class3_selected in enumerate(class3):
+ class3_data = class2_data.loc[
+ class2_data[class3_selection] == class3_selected
+ ]
+
+ fig.add_trace(go.Scatter(
+ x=class3_data[time_selection],
+ y=class3_data[y_selection],
+ name="%s : %s, %s : %s, %s : %s" % (
+ concentration_selection, concentration_selected,
+ class2_selection, class2_selected,
+ class3_selection, class3_selected
+ ),
+ showlegend=True,
+ visible=True,
+ hovertemplate=(
+ "Measurement Measurement Measurement Fit "
+ ''
+ " "
+ " "
+ )
+
+ name = models.CharField(max_length=100, help_text="name of the model")
+ description = models.TextField(
+ help_text="short description of the model", blank=True, default=""
+ )
+ mmt = models.TextField(
+ help_text=(
+ "the model represented using mmt " "(see https://myokit.readthedocs)"
+ ),
+ default=DEFAULT_MMT,
+ )
+ time_max = models.FloatField(
+ default=30,
+ help_text=(
+ "suggested maximum time to simulate for this model (in the time "
+ "units specified by the mmt model)"
+ ),
+ )
+
+ is_library_model = models.BooleanField(
+ default=False,
+ help_text=(
+ "whether this model is a library model (i.e. it is not an "
+ "uploaded user model)"
+ ),
+ )
+
+ class Meta:
+ abstract = True
+
+ def __str__(self):
+ return str(self.name)
+
+ def clean(self):
+ try:
+ self.create_myokit_model()
+ except Exception as e:
+ raise ValidationError({"mmt": str(e)})
diff --git a/pkpdapp/pkpdapp/models/myokit_forward_model.py b/pkpdapp/pkpdapp/models/myokit_forward_model.py
new file mode 100644
index 00000000..9915a67f
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/myokit_forward_model.py
@@ -0,0 +1,332 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import numpy as np
+from sys import float_info
+
+
+class MyokitForwardModel():
+ """
+ Arguments:
+ myokit_model -- a Myokit model.
+ myokit_simulator -- a Myokit simulator.
+ outputs -- a list of strings representing output names
+ times -- a list of ndarrays representing times for each output
+ representing state names in model
+ subjects(=None by default) -- a list of lists of subject ids (0 -> max
+ number of subjects) with the same shape as times, if not None then a
+ simulation will be run for every individual subject and values written
+ out according to this array, if None then only one simulation will be
+ run and then broadcast according to times
+ representing key-value pairs for fixed parameters
+ fixed_parameter_dict(=None by default) -- a dictionary
+ representing key-value pairs for fixed parameters
+ """
+
+ def __init__(
+ self, myokit_simulator, myokit_model,
+ outputs, conversion_factors, times, subjects=None,
+ fixed_parameter_dict=None
+ ):
+ model = myokit_model
+ self._sim = myokit_simulator
+ self._sim.set_tolerance(abs_tol=1e-11, rel_tol=1e-9)
+
+ # get all model states that will be used for inference
+ self._n_states = model.count_states()
+
+ # get initial conditions
+ self._output_names = [
+ var.qname() for var in model.variables(const=False)
+ ]
+
+ self._times = [np.array(t) for t in times]
+ if subjects is None:
+ self._subjects = subjects
+ else:
+ self._subjects = [np.array(s) for s in subjects]
+
+ self._n_subjects = None
+
+ # if we are dealing with subjects split the times according to subject
+ if self._subjects is not None:
+ self._n_subjects = max(
+ [np.max(s_array) for s_array in self._subjects]
+ ) + 1
+ print('n_subjects', self._n_subjects, self._subjects)
+ self._times_all = []
+ self._output_indices = []
+ for s in range(self._n_subjects):
+ times_by_subject = [
+ t_array[s_array == s]
+ for t_array, s_array in zip(self._times, self._subjects)
+ ]
+ self._times_all.append(
+ np.sort(list(set(np.concatenate(times_by_subject))))
+ )
+ self._output_indices.append([
+ np.searchsorted(self._times_all[-1], t)
+ for t in times_by_subject
+ ])
+
+ # if not then just make sure we can map from all times back to output
+ # times
+ else:
+ self._times_all = np.sort(list(set(np.concatenate(self._times))))
+ self._output_indices = [
+ np.searchsorted(self._times_all, t)
+ for t in self._times
+ ]
+
+ self._state_names = [
+ var.qname() for var in model.states()
+ ]
+
+ outputs_not_in_model = (
+ [v not in self._output_names for v in outputs]
+ )
+ if any(outputs_not_in_model):
+ raise ValueError(
+ 'All outputs must be within model. Outputs are:', outputs,
+ '. Outputs in the model are:', self._output_names
+ )
+ self._output_names = outputs
+ self._conversion_factor = {
+ name: conversion_factor
+ for name, conversion_factor in zip(outputs, conversion_factors)
+ }
+ self._n_outputs = len(outputs)
+
+ # find fixed and variable parameters
+ self._const_names = [
+ var.qname() for var in model.variables(const=True)
+ ]
+
+ # parameters are all const variables
+ self._all_parameter_names = self._const_names
+ self._n_all_parameters = len(self._all_parameter_names)
+
+ if fixed_parameter_dict is None:
+ self._fixed_parameter_dict = None
+ self._fixed_parameter_names = None
+ self._fixed_parameter_indices = None
+ self._variable_parameter_names = self._all_parameter_names
+ self._n_parameters = len(self._variable_parameter_names)
+ else:
+ if self._n_all_parameters < len(fixed_parameter_dict):
+ raise ValueError(
+ 'Number of fixed parameters must be fewer'
+ 'than total number of model parameters.'
+ )
+ fparams_not_in_model_params = [p not in self._all_parameter_names
+ for p
+ in fixed_parameter_dict.keys()]
+ if any(fparams_not_in_model_params):
+ raise ValueError(
+ 'All fixed parameter keys must correspond '
+ 'with model keys.'
+ )
+ self._fixed_parameter_dict = fixed_parameter_dict
+ self._fixed_parameter_names = list(fixed_parameter_dict.keys())
+ self._fixed_parameter_list = [
+ self._fixed_parameter_dict[name]
+ for name in self._fixed_parameter_names
+ ]
+ self._variable_parameter_names = [
+ x for x in self._all_parameter_names
+ if x not in self._fixed_parameter_names
+ ]
+ self._n_parameters = len(self._variable_parameter_names)
+ self._fixed_parameter_indices = [
+ self._all_parameter_names.index(v)
+ for v in self._fixed_parameter_names
+ ]
+
+ self._variable_parameter_indices = [
+ self._all_parameter_names.index(v)
+ for v in self._variable_parameter_names
+ ]
+
+ def n_outputs(self):
+ """
+ Returns the number of output dimensions.
+ By default this is the number of states.
+ """
+ return self._n_outputs
+
+ def n_parameters(self):
+ """
+ Returns the number of parameters in the model.
+ Parameters of the model are initial state values and structural
+ parameter values.
+ """
+ return self._n_parameters
+
+ def _set_const(self, parameters):
+ """
+ Sets values of constant model parameters.
+ """
+ for id_var, var in enumerate(self._const_names):
+ self._sim.set_constant(var, float(parameters[id_var]))
+
+ def _set_init(self, parameters):
+ """
+ Sets initial conditions of model.
+ """
+ model = self._sim._model
+ for id_var, var in enumerate(self._const_names):
+ model.get(var).set_rhs(float(parameters[id_var]))
+ states = model.initial_values(as_floats=True)
+
+ self._sim.set_state(states)
+
+ def simulate(self, parameters):
+ """
+ Returns the numerical solution of the model outputs for specified
+ parameters. Note, the parameter inputs should be ordered as
+ in `variable_parameter_names()`.
+
+ parameters should be 1d if self._subjects is None, 2d if self._subjects
+ is not None, with shape (n_parameters, n_subjects)
+ """
+ parameters = np.array(parameters)
+
+ if self._subjects is None and parameters.ndim != 1:
+ raise ValueError(
+ 'no subjects provided, but parameters shape is {}'.format(
+ parameters.shape
+ )
+ )
+
+ if self._subjects is not None and parameters.ndim != 2:
+ raise ValueError(
+ 'subjects provided, but parameters shape is {}'.format(
+ parameters.shape
+ )
+ )
+
+ if parameters.shape[0] != self._n_parameters:
+ raise ValueError('Dim 0 of parameters supplied must equal ' +
+ 'number of non-fixed model parameters.')
+
+ if (
+ self._subjects is not None and
+ parameters.shape[1] != self._n_subjects
+ ):
+ raise ValueError('Dim 1 of of parameters supplied must equal ' +
+ 'number of subjects.')
+
+ if self._subjects is None:
+ # ensure order of parameters works
+ if self._fixed_parameter_dict is None:
+ full_parameters = parameters
+ else:
+ full_parameters = np.empty((self._n_all_parameters))
+
+ # fill up parameter vector with fixed and variable values
+ for count, idx in enumerate(self._fixed_parameter_indices):
+ full_parameters[idx] = self._fixed_parameter_list[count]
+ for count, idx in enumerate(self._variable_parameter_indices):
+ full_parameters[idx] = parameters[count]
+
+ # Reset simulation
+ self._sim.reset()
+
+ # Set constant model parameters
+ self._set_const(full_parameters)
+
+ # Set initial conditions
+ self._set_init(full_parameters)
+
+ # Simulate: need +100*epsilon for times to ensure simulation
+ # surpasses last time
+ t_max = self._times_all[-1] + 1e2 * float_info.epsilon
+ log_times = self._times_all
+ output = self._sim.run(
+ t_max,
+ log=self._output_names, log_times=log_times
+ )
+
+ output = self._convert_units(output)
+
+ result = [
+ np.array(output[name])[indices]
+ for name, indices in zip(
+ self._output_names,
+ self._output_indices
+ )
+ ]
+ else:
+ # ensure order of parameters works
+ if self._fixed_parameter_dict is None:
+ full_parameters = parameters
+ else:
+ full_parameters = np.empty((self._n_all_parameters,
+ self._n_subjects))
+
+ # fill up parameter vector with fixed and variable values
+ for count, idx in enumerate(self._fixed_parameter_indices):
+ full_parameters[idx, :] = self._fixed_parameter_list[count]
+ for count, idx in enumerate(self._variable_parameter_indices):
+ full_parameters[idx, :] = parameters[count, :]
+
+ # preallocate results
+ result = [
+ np.empty_like(t) for t in self._times
+ ]
+ for s in range(self._n_subjects):
+ # Reset simulation
+ self._sim.reset()
+
+ # Set constant model parameters
+ self._set_const(full_parameters[:, s])
+
+ # Set initial conditions
+ self._set_init(full_parameters[:, s])
+
+ # Simulate: need +100*epsilon for times to ensure simulation
+ # surpasses last time
+ t_max = self._times_all[s][-1] + 1e2 * float_info.epsilon
+ log_times = self._times_all[s]
+ output = self._sim.run(
+ t_max,
+ log=self._output_names, log_times=log_times
+ )
+
+ output = self._convert_units(output)
+
+ # scatter this subject's output across result according to
+ # output_indices
+ for output_index, (name, indices, subjects) in enumerate(zip(
+ self._output_names,
+ self._output_indices[s],
+ self._subjects,
+ )):
+ result[output_index][s == subjects] = \
+ np.array(output[name])[indices]
+
+ return result
+
+ def _convert_units(self, output):
+ for key, value in output.items():
+ output[key] = self._conversion_factor[key] * np.frombuffer(value)
+ return output
+
+ def output_names(self):
+ """ Returns outputs of model. """
+ return self._output_names
+
+ def output_shapes(self):
+ """ Returns outputs of model. """
+ return [t.shape for t in self._times]
+
+ def variable_parameter_names(self):
+ """ The order expected for parameter inputs to simulate. """
+ return self._variable_parameter_names
+
+ def fixed_parameter_names(self):
+ """ The fixed parameters of model. """
+ return self._fixed_parameter_names
diff --git a/pkpdapp/pkpdapp/models/myokit_model_mixin.py b/pkpdapp/pkpdapp/models/myokit_model_mixin.py
new file mode 100644
index 00000000..9f824b3a
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/myokit_model_mixin.py
@@ -0,0 +1,674 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp
+import numpy as np
+from myokit.formats.mathml import MathMLExpressionWriter
+from myokit.formats.sbml import SBMLParser
+import myokit
+import threading
+from django.core.cache import cache
+import logging
+
+logger = logging.getLogger(__name__)
+
+lock = threading.Lock()
+
+
+class MyokitModelMixin:
+ def _get_myokit_model_cache_key(self):
+ return "myokit_model_{}_{}".format(self._meta.db_table, self.id)
+
+ def _get_myokit_simulator_cache_key(self):
+ return "myokit_simulator_{}_{}".format(self._meta.db_table, self.id)
+
+ @staticmethod
+ def sbml_string_to_mmt(sbml):
+ model = MyokitModelMixin.parse_sbml_string(sbml)
+ return model.code()
+
+ @staticmethod
+ def parse_sbml_string(sbml):
+ with lock:
+ model = SBMLParser().parse_string(str.encode(sbml)).myokit_model()
+ return model
+
+ @staticmethod
+ def parse_mmt_string(mmt):
+ with lock:
+ model, _, _ = myokit.parse(mmt)
+ return model
+
+ def create_myokit_model(self):
+ return self.parse_mmt_string(self.mmt)
+
+ def create_myokit_simulator(self, override_tlag=None, model=None, time_max=None):
+ if override_tlag is None:
+ override_tlag = {}
+
+ if model is None:
+ model = self.get_myokit_model()
+
+ from pkpdapp.models import Variable
+
+ if override_tlag is None:
+ try:
+ tlag_value = self.variables.get(
+ qname="PKCompartment.tlag"
+ ).default_value
+ except Variable.DoesNotExist:
+ tlag_value = 0.0
+ else:
+ tlag_value = override_tlag
+
+ # add a dose_rate variable to the model for each
+ # dosed variable
+ for v in self.variables.filter(state=True):
+ if v.protocol:
+ myokit_v = model.get(v.qname)
+ set_administration(model, myokit_v)
+
+ protocols = {}
+ project = self.get_project()
+ if project is None:
+ compound = None
+ else:
+ compound = project.compound
+ for v in self.variables.filter(state=True):
+ if v.protocol:
+ # get tlag value default to 0
+ derived_param = v.qname + "_tlag_ud"
+ try:
+ tlag_value = self.variables.get(qname=derived_param).default_value
+ except Variable.DoesNotExist:
+ tlag_value = 0.0
+
+ # override tlag if set
+ if v.qname in override_tlag:
+ tlag_value = override_tlag[v.qname]
+
+ amount_var = model.get(v.qname)
+ time_var = model.binding("time")
+
+ is_target = False
+ if self.is_library_model:
+ is_target = "CT1" in v.qname or "AT1" in v.qname
+
+ amount_conversion_factor = v.protocol.amount_unit.convert_to(
+ amount_var.unit(), compound=compound, is_target=is_target
+ )
+
+ time_conversion_factor = v.protocol.time_unit.convert_to(
+ time_var.unit(), compound=compound
+ )
+
+ dosing_events = []
+ last_dose_time = tlag_value
+ for d in v.protocol.doses.all():
+ if d.repeat_interval <= 0:
+ continue
+ start_times = np.arange(
+ d.start_time + last_dose_time,
+ d.start_time + last_dose_time + d.repeat_interval * d.repeats,
+ d.repeat_interval,
+ )
+ if len(start_times) == 0:
+ continue
+ last_dose_time = start_times[-1]
+ dosing_events += [
+ (
+ (amount_conversion_factor / time_conversion_factor)
+ * (d.amount / d.duration),
+ time_conversion_factor * start_time,
+ time_conversion_factor * d.duration,
+ )
+ for start_time in start_times
+ ]
+ # if any dosing events are close to time_max,
+ # make them equal to time_max
+ if time_max is not None:
+ for i, (level, start, duration) in enumerate(dosing_events):
+ if abs(start - time_max) < 1e-6:
+ dosing_events[i] = (level, time_max, duration)
+ elif abs(start + duration - time_max) < 1e-6:
+ dosing_events[i] = (level, start, time_max - start)
+ protocols[_get_pacing_label(amount_var)] = get_protocol(dosing_events)
+
+ with lock:
+ sim = myokit.Simulation(model, protocol=protocols)
+ return sim
+
+ def get_myokit_simulator(self):
+ key = self._get_myokit_simulator_cache_key()
+ with lock:
+ myokit_simulator = cache.get(key)
+ if myokit_simulator is None:
+ myokit_simulator = self.create_myokit_simulator()
+ cache.set(key, myokit_simulator, timeout=None)
+ return myokit_simulator
+
+ def get_myokit_model(self):
+ key = self._get_myokit_model_cache_key()
+ with lock:
+ myokit_model = cache.get(key)
+ if myokit_model is None:
+ myokit_model = self.create_myokit_model()
+ cache.set(key, myokit_model, timeout=None)
+ return myokit_model
+
+ def is_variables_out_of_date(self):
+ model = self.get_myokit_model()
+
+ # just check if the number of const variables is right
+ # TODO: is this sufficient, we are also updating on save
+ # so I think it should be ok....?
+ all_const_variables = self.variables.filter(constant=True)
+ myokit_variable_count = sum(1 for _ in model.variables(const=True, sort=True))
+ # check if variables need updating
+ return len(all_const_variables) != myokit_variable_count
+
+ def update_simulator(self):
+ # delete simulator from cache
+ cache.delete(self._get_myokit_simulator_cache_key())
+
+ def update_model(self):
+ logger.info("UPDATE MODEL")
+ # delete model and simulators from cache
+ cache.delete(self._get_myokit_simulator_cache_key())
+ cache.delete(self._get_myokit_model_cache_key())
+
+ # update the variables of the model
+ from pkpdapp.models import Variable
+
+ removed_variables = []
+ if self.is_library_model:
+ removed_variables += [
+ "PKCompartment.b_term",
+ "PKCompartment.c_term",
+ ]
+ if not getattr(self, "has_saturation", True):
+ removed_variables += ["PKCompartment.Km", "PKCompartment.CLmax"]
+ if not getattr(self, "has_effect", True):
+ removed_variables += [
+ "PKCompartment.Ce",
+ "PKCompartment.AUCe",
+ "PKCompartment.ke0",
+ "PKCompartment.Kpu",
+ "PKCompartment.Kp",
+ ]
+ if not getattr(self, "has_hill_coefficient", True):
+ removed_variables += ["PDCompartment.HC"]
+ # tlag now on per variable basis
+ removed_variables += ["PKCompartment.tlag"]
+ if not getattr(self, "has_bioavailability", True):
+ removed_variables += ["PKCompartment.F"]
+
+ model = self.get_myokit_model()
+ new_variables = [
+ Variable.get_variable(self, v)
+ for v in model.variables(const=True, sort=True)
+ if v.is_literal() and v.qname() not in removed_variables
+ ]
+
+ # parameters could originally be outputs
+ for v in new_variables:
+ if not v.constant:
+ v.constant = True
+ v.save()
+ new_states = [
+ Variable.get_variable(self, v)
+ for v in model.variables(state=True, sort=True)
+ if v.qname() not in removed_variables
+ ]
+ new_outputs = [
+ Variable.get_variable(self, v)
+ for v in model.variables(const=False, state=False, sort=True)
+ if v.qname() not in removed_variables
+ ]
+ logger.debug("ALL NEW OUTPUTS")
+ for v in new_outputs:
+ if v.unit is not None:
+ logger.debug(
+ f"{v.qname} [{v.unit.symbol}], "
+ f"id = {v.id} constant = {v.constant}, "
+ f"state = {v.state}"
+ )
+ else:
+ logger.debug(
+ f"{v.qname}, id = {v.id} "
+ f"constant = {v.constant}, "
+ f"state = {v.state}"
+ )
+
+ for v in new_outputs:
+ # if output not in states set state false
+ # so only states with initial conditions as
+ # parameters will have state set to true
+ if v not in new_states and v.state is True:
+ v.state = False
+ v.save()
+
+ # parameters could originally be variables
+ if v.constant:
+ v.constant = False
+ v.save()
+
+ all_new_variables = new_variables + new_states + new_outputs
+ logger.debug("ALL NEW VARIABLES")
+ for v in all_new_variables:
+ if v.unit is not None:
+ logger.debug(
+ f"{v.qname} [{v.unit.symbol}], id = {v.id} "
+ f"constant = {v.constant}, state = {v.state}"
+ )
+ else:
+ logger.debug(
+ f"{v.qname}, id = {v.id} "
+ f"constant = {v.constant}, state = {v.state}"
+ )
+
+ # for library models: set new variables to defaults
+ if self.is_library_model and hasattr(self, "reset_params_to_defaults"):
+ project = self.get_project()
+ if project is not None:
+ species = project.species
+ compound_type = project.compound.compound_type
+ self.reset_params_to_defaults(species, compound_type, all_new_variables)
+
+ # delete all variables that are not in new
+ for variable in self.variables.all():
+ if variable not in all_new_variables:
+ logger.debug(f"DELETING VARIABLE {variable.qname} (id = {variable.id})")
+ variable.delete()
+ else:
+ logger.debug(
+ f"RETAINING VARIABLE {variable.qname} (id = {variable.id}, value = {variable.default_value})" # noqa: E501
+ )
+
+ self.variables.set(all_new_variables)
+
+ def set_variables_from_inference(self, inference):
+ results_for_mle = inference.get_maximum_likelihood()
+ for result in results_for_mle:
+ inference_var = result.log_likelihood.outputs.first().variable
+ # noise variables won't have a model variable
+ if inference_var is not None:
+ model_var = self.variables.filter(qname=inference_var.qname).first()
+ else:
+ model_var = None
+ if model_var is not None:
+ model_var.default_value = result.value
+ if (
+ model_var.lower_bound
+ and model_var.lower_bound > model_var.default_value
+ ):
+ model_var.lower_bound = model_var.default_value
+ if (
+ model_var.upper_bound
+ and model_var.upper_bound < model_var.default_value
+ ):
+ model_var.upper_bound = model_var.default_value
+ model_var.save()
+
+ @staticmethod
+ def _serialise_equation(equ):
+ writer = MathMLExpressionWriter()
+ writer.set_mode(presentation=True)
+ return writer.eq(equ)
+
+ @staticmethod
+ def _serialise_variable(var):
+ return {
+ "name": var.name(),
+ "qname": var.qname(),
+ "unit": str(var.unit()),
+ "default_value": float(var.value()),
+ "lower_bound": 0.0,
+ "upper_bound": 2.0,
+ "scale": "LN",
+ }
+
+ @classmethod
+ def _serialise_component(cls, c):
+ states = [
+ cls._serialise_variable(s) for s in c.variables(state=True, sort=True)
+ ]
+ variables = [
+ cls._serialise_variable(v) for v in c.variables(const=True, sort=True)
+ ]
+ outputs = [
+ cls._serialise_variable(o) for o in c.variables(const=False, sort=True)
+ ]
+ equations = [
+ cls._serialise_equation(e) for e in c.equations(bound=False, const=False)
+ ]
+ return {
+ "name": c.name(),
+ "states": states,
+ "variables": variables,
+ "outputs": outputs,
+ "equations": equations,
+ }
+
+ def states(self):
+ """states are dependent variables of the model to be solved"""
+ model = self.get_myokit_model()
+ states = model.variables(state=True, sort=True)
+ return [self._serialise_variable(s) for s in states]
+
+ def components(self):
+ """
+ outputs are dependent (e.g. y) and independent (e.g. time)
+ variables of the model to be solved
+ """
+ model = self.get_myokit_model()
+ return [self._serialise_component(c) for c in model.components(sort=True)]
+
+ def outputs(self):
+ """
+ outputs are dependent (e.g. y) and independent (e.g. time)
+ variables of the model to be solved
+ """
+ model = self.get_myokit_model()
+ outpts = model.variables(const=False, sort=True)
+ return [self._serialise_variable(o) for o in outpts]
+
+ def myokit_variables(self):
+ """
+ variables are independent variables of the model that are constant
+ over time. aka parameters of the model
+ """
+ model = self.get_myokit_model()
+ variables = model.variables(const=True, sort=True)
+ return [self._serialise_variable(v) for v in variables]
+
+ def _convert_unit(self, variable, myokit_variable_sbml, value):
+ is_target = False
+ if self.is_library_model:
+ is_target = "CT1" in variable.qname or "AT1" in variable.qname
+ if variable.unit is None:
+ conversion_factor = 1.0
+ else:
+ project = self.get_project()
+ compound = None
+ if project is not None:
+ compound = project.compound
+ conversion_factor = variable.unit.convert_to(
+ myokit_variable_sbml.unit(), compound=compound, is_target=is_target
+ )
+
+ return conversion_factor * value
+
+ def _convert_unit_qname(self, qname, value, myokit_model):
+ variable = self.variables.get(qname=qname)
+ myokit_variable_sbml = myokit_model.get(qname)
+ new_value = self._convert_unit(variable, myokit_variable_sbml, value)
+ return new_value
+
+ def _convert_bound_unit(self, binding, value, myokit_model):
+ myokit_variable_sbml = myokit_model.binding(binding)
+ variable = self.variables.get(qname=myokit_variable_sbml.qname())
+ return self._convert_unit(variable, myokit_variable_sbml, value)
+
+ if variable.unit is None:
+ conversion_factor = 1.0
+ else:
+ conversion_factor = myokit.Unit.conversion_factor(
+ variable.unit.get_myokit_unit(), myokit_variable_sbml.unit()
+ ).value()
+
+ return conversion_factor * value
+
+ def serialize_datalog(self, datalog, myokit_model):
+ result = {}
+ for k, v in datalog.items():
+ variable = self.variables.get(qname=k)
+ myokit_variable_sbml = myokit_model.get(k)
+
+ if variable.unit is None:
+ conversion_factor = 1.0
+ else:
+ conversion_factor = myokit.Unit.conversion_factor(
+ myokit_variable_sbml.unit(), variable.unit.get_myokit_unit()
+ ).value()
+
+ result[variable.id] = (conversion_factor * np.frombuffer(v)).tolist()
+
+ return result
+
+ def get_time_max(self):
+ return self.time_max
+
+ def simulate(self, outputs=None, variables=None, time_max=None):
+ """
+ Arguments
+ ---------
+ outputs: list
+ list of output names to return
+ variables: dict
+ dict mapping variable names to values for model parameters
+ time_max: float
+ maximum time to simulate to
+
+ Returns
+ -------
+ output: myokit.DataLog
+ a DataLog containing the solution, which is effectivly a dict
+ mapping output names to arrays of values
+ """
+
+ if time_max is None:
+ time_max = self.get_time_max()
+
+ if outputs is None:
+ outputs = []
+
+ default_variables = {
+ v.qname: v.get_default_value() for v in self.variables.filter(constant=True)
+ }
+ if variables is None:
+ variables = default_variables
+ else:
+ variables = {
+ **default_variables,
+ **variables,
+ }
+
+ model = self.get_myokit_model()
+
+ # Convert units
+ variables = {
+ qname: self._convert_unit_qname(qname, value, model)
+ for qname, value in variables.items()
+ }
+ time_max = self._convert_bound_unit("time", time_max, model)
+
+ # Set constants in model
+ for var_name, var_value in variables.items():
+ model.get(var_name).set_rhs(float(var_value))
+
+ # create simulator
+
+ # get tlag vars
+ override_tlag = {}
+ if isinstance(self, pkpdapp.models.CombinedModel):
+ for dv in self.derived_variables.all():
+ if dv.type == "TLG":
+ derived_param = dv.pk_variable.qname + "_tlag_ud"
+ if derived_param in variables:
+ override_tlag[dv.pk_variable.qname] = variables[derived_param]
+
+ sim = self.create_myokit_simulator(
+ override_tlag=override_tlag, model=model, time_max=time_max
+ )
+ # TODO: take these from simulation model
+ sim.set_tolerance(abs_tol=1e-06, rel_tol=1e-08)
+
+ # Simulate, logging only state variables given by `outputs`
+ return self.serialize_datalog(sim.run(time_max, log=outputs), model)
+
+
+def set_administration(model, drug_amount, direct=True):
+ r"""
+ Sets the route of administration of the compound.
+
+ The compound is administered to the selected compartment either
+ directly or indirectly. If it is administered directly, a dose rate
+ variable is added to the drug amount's rate of change expression
+
+ .. math ::
+
+ \frac{\text{d}A}{\text{d}t} = \text{RHS} + r_d,
+
+ where :math:`A` is the drug amount in the selected compartment, RHS is
+ the rate of change of :math:`A` prior to adding the dose rate, and
+ :math:`r_d` is the dose rate.
+
+ The dose rate can be set by :meth:`set_dosing_regimen`.
+
+ If the route of administration is indirect, a dosing compartment
+ is added to the model, which is connected to the selected compartment.
+ The dose rate variable is then added to the rate of change expression
+ of the dose amount variable in the dosing compartment. The drug amount
+ in the dosing compartment flows at a linear absorption rate into the
+ selected compartment
+
+ .. math ::
+
+ \frac{\text{d}A_d}{\text{d}t} = -k_aA_d + r_d \\
+ \frac{\text{d}A}{\text{d}t} = \text{RHS} + k_aA_d,
+
+ where :math:`A_d` is the amount of drug in the dose compartment and
+ :math:`k_a` is the absorption rate.
+
+ Setting an indirect administration route changes the number of
+ parameters of the model, and resets the parameter names to their
+ defaults.
+
+ Parameters
+ ----------
+ compartment
+ Compartment to which doses are either directly or indirectly
+ administered.
+ amount_var
+ Drug amount variable in the compartment. By default the drug amount
+ variable is assumed to be 'drug_amount'.
+ direct
+ A boolean flag that indicates whether the dose is administered
+ directly or indirectly to the compartment.
+ """
+ if not drug_amount.is_state():
+ raise ValueError(
+ "The variable <" + str(drug_amount) + "> is not a state "
+ "variable, and can therefore not be dosed."
+ )
+
+ # If administration is indirect, add a dosing compartment and update
+ # the drug amount variable to the one in the dosing compartment
+ time_unit = _get_time_unit(model)
+ if not direct:
+ drug_amount = _add_dose_compartment(model, drug_amount, time_unit)
+
+ # Add dose rate variable to the right hand side of the drug amount
+ _add_dose_rate(drug_amount, time_unit)
+
+
+def get_protocol(events):
+ """
+
+ Parameters
+ ----------
+ events
+ list of (level, start, duration)
+ """
+ myokit_protocol = myokit.Protocol()
+ for e in events:
+ myokit_protocol.schedule(e[0], e[1], e[2])
+
+ return myokit_protocol
+
+
+def _get_pacing_label(variable):
+ return f'pace_{variable.qname().replace(".", "_")}'
+
+
+def _add_dose_rate(drug_amount, time_unit):
+ """
+ Adds a dose rate variable to the state variable, which is bound to the
+ dosing regimen.
+ """
+ # Register a dose rate variable to the compartment and bind it to
+ # pace, i.e. tell myokit that its value is set by the dosing regimen/
+ # myokit.Protocol
+ compartment = drug_amount.parent()
+ dose_rate = compartment.add_variable_allow_renaming(str("dose_rate"))
+ dose_rate.set_binding(_get_pacing_label(drug_amount))
+
+ # Set initial value to 0 and unit to unit of drug amount over unit of
+ # time
+ dose_rate.set_rhs(0)
+ drug_amount_unit = drug_amount.unit()
+ if drug_amount_unit is not None and time_unit is not None:
+ dose_rate.set_unit(drug_amount.unit() / time_unit)
+
+ # Add the dose rate to the rhs of the drug amount variable
+ rhs = drug_amount.rhs()
+ drug_amount.set_rhs(myokit.Plus(rhs, myokit.Name(dose_rate)))
+
+
+def _get_time_unit(model):
+ """
+ Gets the model's time unit.
+ """
+ # Get bound variables
+ bound_variables = [var for var in model.variables(bound=True)]
+
+ # Get the variable that is bound to time
+ # (only one can exist in myokit.Model)
+ for var in bound_variables:
+ if var._binding == "time":
+ return var.unit()
+
+
+def _add_dose_compartment(model, drug_amount, time_unit):
+ """
+ Adds a dose compartment to the model with a linear absorption rate to
+ the connected compartment.
+ """
+ # Add a dose compartment to the model
+ dose_comp = model.add_component_allow_renaming("dose")
+
+ # Create a state variable for the drug amount in the dose compartment
+ dose_drug_amount = dose_comp.add_variable("drug_amount")
+ dose_drug_amount.set_rhs(0)
+ dose_drug_amount.set_unit(drug_amount.unit())
+ dose_drug_amount.promote()
+
+ # Create an absorption rate variable
+ absorption_rate = dose_comp.add_variable("absorption_rate")
+ absorption_rate.set_rhs(1)
+ absorption_rate.set_unit(1 / time_unit)
+
+ # Add outflow expression to dose compartment
+ dose_drug_amount.set_rhs(
+ myokit.Multiply(
+ myokit.PrefixMinus(myokit.Name(absorption_rate)),
+ myokit.Name(dose_drug_amount),
+ )
+ )
+
+ # Add inflow expression to connected compartment
+ rhs = drug_amount.rhs()
+ drug_amount.set_rhs(
+ myokit.Plus(
+ rhs,
+ myokit.Multiply(
+ myokit.Name(absorption_rate), myokit.Name(dose_drug_amount)
+ ),
+ )
+ )
+
+ return dose_drug_amount
diff --git a/pkpdapp/pkpdapp/models/pharmacodynamic_model.py b/pkpdapp/pkpdapp/models/pharmacodynamic_model.py
new file mode 100644
index 00000000..e2298688
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/pharmacodynamic_model.py
@@ -0,0 +1,62 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.db import models
+from django.urls import reverse
+from pkpdapp.models import (
+ MechanisticModel,
+ Project,
+ StoredModel,
+)
+
+
+class PharmacodynamicModel(MechanisticModel, StoredModel):
+ project = models.ForeignKey(
+ Project, on_delete=models.CASCADE,
+ related_name='pd_models',
+ blank=True, null=True,
+ help_text='Project that "owns" this model'
+ )
+ __original_mmt = None
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.__original_mmt = self.mmt
+
+ def get_absolute_url(self):
+ return reverse('pd_model-detail', kwargs={'pk': self.pk})
+
+ def get_project(self):
+ return self.project
+
+ def save(self, force_insert=False, force_update=False, *args, **kwargs):
+ created = not self.pk
+
+ super().save(force_insert, force_update, *args, **kwargs)
+
+ # don't update a stored model
+ if self.read_only:
+ return
+
+ if created or self.mmt != self.__original_mmt:
+ self.update_model()
+
+ self.__original_mmt = self.mmt
+
+ def create_stored_model(self):
+ stored_model_kwargs = {
+ 'name': self.name,
+ 'description': self.description,
+ 'project': self.project,
+ 'mmt': self.mmt,
+ 'time_max': self.time_max,
+ 'read_only': True,
+ }
+ stored_model = PharmacodynamicModel.objects.create(
+ **stored_model_kwargs)
+ for variable in self.variables.all():
+ variable.create_stored_variable(stored_model)
+ return stored_model
diff --git a/pkpdapp/pkpdapp/models/pharmacokinetic_model.py b/pkpdapp/pkpdapp/models/pharmacokinetic_model.py
new file mode 100644
index 00000000..10d97295
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/pharmacokinetic_model.py
@@ -0,0 +1,57 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.urls import reverse
+from pkpdapp.models import (
+ MechanisticModel,
+ StoredModel,
+)
+
+
+class PharmacokineticModel(MechanisticModel, StoredModel):
+ """
+ this just creates a concrete table for PK models without dosing
+ """
+ __original_mmt = None
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.__original_mmt = self.mmt
+
+ def get_project(self):
+ return None
+
+ def get_absolute_url(self):
+ return reverse('pk_model-detail', kwargs={'pk': self.pk})
+
+ def save(self, force_insert=False, force_update=False, *args, **kwargs):
+ created = not self.pk
+
+ super().save(force_insert, force_update, *args, **kwargs)
+
+ # don't update a stored model
+ if self.read_only:
+ return
+
+ if created or self.mmt != self.__original_mmt:
+ self.update_model()
+
+ self.__original_mmt = self.mmt
+
+ def create_stored_model(self):
+ stored_model_kwargs = {
+ 'name': self.name,
+ 'description': self.description,
+ 'mmt': self.mmt,
+ 'time_max': self.time_max,
+ 'read_only': True,
+ }
+ stored_model = PharmacokineticModel.objects.create(
+ **stored_model_kwargs)
+
+ # no need to store variables as they will be stored with the dosed pk
+ # model
+ return stored_model
diff --git a/pkpdapp/pkpdapp/models/profile.py b/pkpdapp/pkpdapp/models/profile.py
new file mode 100644
index 00000000..9dd62acd
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/profile.py
@@ -0,0 +1,16 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.db import models
+from django.contrib.auth.models import User
+
+
+class Profile(models.Model):
+ """
+ A user profile, containing neccessary information for users not held in
+ :model:`auth.User`.
+ """
+ user = models.OneToOneField(User, on_delete=models.CASCADE)
diff --git a/pkpdapp/pkpdapp/models/project.py b/pkpdapp/pkpdapp/models/project.py
new file mode 100644
index 00000000..6b901b2d
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/project.py
@@ -0,0 +1,68 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.db import models
+from django.contrib.auth.models import User
+from django.urls import reverse
+
+
+class Project(models.Model):
+ """
+ A project, containing multiple :model:`pkpdapp.Dataset`,
+ :model:`pkpdapp.PkpdModel` and users.
+ """
+ name = models.CharField(max_length=100, help_text='name of the project')
+ description = models.TextField(
+ help_text='short description of the project',
+ blank=True, default=''
+ )
+ users = models.ManyToManyField(
+ User,
+ through='ProjectAccess',
+ help_text='users with access to this project'
+ )
+
+ compound = models.OneToOneField(
+ 'Compound', on_delete=models.CASCADE,
+ )
+
+ created = models.DateTimeField(auto_now_add=True)
+
+ # species is a enum field
+ class Species(models.TextChoices):
+ MOUSE = 'M', 'Mouse'
+ RAT = 'R', 'Rat'
+ HUMAN = 'H', 'Human'
+ MONKEY = 'K', 'Monkey'
+ OTHER = 'O', 'Other'
+
+ species = models.CharField(
+ max_length=1,
+ choices=Species.choices,
+ default=Species.OTHER,
+ help_text='subject species'
+ )
+
+ def get_absolute_url(self):
+ return reverse('project-detail', kwargs={'pk': self.pk})
+
+ def __str__(self):
+ return str(self.name)
+
+
+class ProjectAccess(models.Model):
+ user = models.ForeignKey(User, on_delete=models.CASCADE)
+ project = models.ForeignKey(Project, on_delete=models.CASCADE)
+ read_only = models.BooleanField(
+ default=False,
+ help_text='True if user has read access only'
+ )
+
+ class Meta:
+ unique_together = ('user', 'project',)
+
+ def get_project(self):
+ return self.project
diff --git a/pkpdapp/pkpdapp/models/protocol.py b/pkpdapp/pkpdapp/models/protocol.py
new file mode 100644
index 00000000..ff94a26a
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/protocol.py
@@ -0,0 +1,151 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.db import models
+from django.urls import reverse
+from pkpdapp.models import (
+ Compound, Unit,
+ Project, StoredModel,
+)
+
+
+def get_h_unit():
+ try:
+ return Unit.objects.get(symbol='h')
+ except Unit.DoesNotExist:
+ return None
+
+
+def get_mg_unit():
+ try:
+ return Unit.objects.get(symbol='mg')
+ except Unit.DoesNotExist:
+ return None
+
+
+class Protocol(StoredModel):
+ """
+ Multiple doses forming a single protocol. Can optionally be associated with
+ a compound, dataset and subject.
+ """
+
+ name = models.CharField(
+ max_length=100, help_text='name of the protocol'
+ )
+ project = models.ForeignKey(
+ Project, on_delete=models.CASCADE,
+ related_name='protocols',
+ blank=True, null=True,
+ help_text='Project that "owns" this protocol.'
+ )
+ compound = models.ForeignKey(
+ Compound, on_delete=models.PROTECT,
+ blank=True, null=True,
+ help_text='drug compound'
+ )
+
+ class DoseType(models.TextChoices):
+ DIRECT = 'D', 'IV'
+ INDIRECT = 'I', 'Extravascular'
+
+ dose_type = models.CharField(
+ max_length=1,
+ choices=DoseType.choices,
+ default=DoseType.DIRECT,
+ )
+
+ time_unit = models.ForeignKey(
+ Unit, on_delete=models.PROTECT,
+ blank=True, null=True,
+ default=get_h_unit,
+ related_name='protocols_time',
+ help_text=(
+ 'unit for the start_time and duration values stored in each dose'
+ )
+ )
+
+ amount_unit = models.ForeignKey(
+ Unit, on_delete=models.PROTECT,
+ default=get_mg_unit,
+ blank=True, null=True,
+ related_name='protocols_amount',
+ help_text='unit for the amount value stored in each dose'
+ )
+
+ __original_dose_type = None
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.__original_dose_type = self.dose_type
+
+ def get_absolute_url(self):
+ return reverse('protocol-detail', kwargs={'pk': self.pk})
+
+ def get_project(self):
+ if self.project:
+ return self.project
+ else:
+ subject = self.subjects.first()
+ if subject is not None:
+ return subject.get_project()
+
+ return None
+
+ def __str__(self):
+ return str(self.name)
+
+ def get_dataset(self):
+ all_datasets = self.subjects.values('dataset').distinct()
+ if all_datasets:
+ return all_datasets[0]['dataset']
+ return None
+
+ def is_same_as(self, protocol):
+ if self.project != protocol.project:
+ return False
+ if self.compound != protocol.compound:
+ return False
+ if self.dose_type != protocol.dose_type:
+ return False
+ if self.time_unit != protocol.time_unit:
+ return False
+ if self.time_unit != protocol.time_unit:
+ return False
+ if self.amount_unit != protocol.amount_unit:
+ return False
+
+ my_doses = self.doses.order_by('start_time')
+ other_doses = protocol.doses.order_by('start_time')
+ for my_dose, other_dose in zip(my_doses, other_doses):
+ if not my_dose.is_same_as(other_dose):
+ return False
+ return True
+
+ def save(self, force_insert=False, force_update=False, *args, **kwargs):
+ super().save(force_insert, force_update, *args, **kwargs)
+
+ if self.dose_type != self.__original_dose_type:
+ for dosed_pk_model in self.dosed_pk_models.all():
+ dosed_pk_model.update_model()
+
+ self.__original_dose_type = self.dose_type
+
+ def create_stored_protocol(self):
+ if self.read_only:
+ return self
+ stored_protocol_kwargs = {
+ 'name': self.name,
+ 'project': self.project,
+ 'compound': self.compound,
+ 'dose_type': self.dose_type,
+ 'time_unit': self.time_unit,
+ 'amount_unit': self.amount_unit,
+ 'read_only': True,
+ }
+ stored_protocol = Protocol.objects.create(**stored_protocol_kwargs)
+ for dose in self.doses.all():
+ dose.create_stored_dose(stored_protocol)
+ return stored_protocol
diff --git a/pkpdapp/pkpdapp/models/simulation.py b/pkpdapp/pkpdapp/models/simulation.py
new file mode 100644
index 00000000..57aaf400
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/simulation.py
@@ -0,0 +1,174 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.db import models
+from django.core.validators import MinValueValidator
+
+
+# class to store options for simulation and plotting of results
+# a project can have multiple simulations
+class Simulation(models.Model):
+ """
+ A simulation, containing multiple :model:`pkpdapp.Dataset`,
+ :model:`pkpdapp.PkpdModel` and users.
+ """
+
+ name = models.CharField(max_length=100, help_text="name of the simulation")
+
+ project = models.ForeignKey(
+ "Project",
+ on_delete=models.CASCADE,
+ related_name="simulations",
+ )
+
+ nrows = models.IntegerField(default=1, help_text="number of subplot rows")
+
+ ncols = models.IntegerField(default=1, help_text="number of subplot columns")
+
+ time_max = models.FloatField(
+ default=30,
+ validators=[MinValueValidator(0)],
+ help_text="maximum time for the simulation",
+ )
+
+ time_max_unit = models.ForeignKey(
+ "Unit",
+ on_delete=models.PROTECT,
+ related_name="simulation_time_max",
+ help_text="unit for maximum time",
+ )
+
+ abs_tolerance = models.FloatField(
+ default=1e-6,
+ validators=[MinValueValidator(0)],
+ help_text="absolute tolerance for the simulation",
+ )
+
+ rel_tolerance = models.FloatField(
+ default=1e-6,
+ validators=[MinValueValidator(0)],
+ help_text="relative tolerance for the simulation",
+ )
+
+ def get_project(self):
+ return self.project
+
+
+# model for a simulation plot
+
+
+class SimulationPlot(models.Model):
+ simulation = models.ForeignKey(
+ "Simulation", on_delete=models.CASCADE, related_name="plots"
+ )
+ index = models.IntegerField(help_text="index of the plot in the simulation")
+
+ class ScaleOptions(models.TextChoices):
+ LINEAR = "lin", "Linear"
+ LOG2 = "lg2", "Log2"
+ LOG10 = "lg10", "Log10"
+ LN = "ln", "Ln"
+
+ x_scale = models.CharField(
+ max_length=4,
+ choices=ScaleOptions.choices,
+ default=ScaleOptions.LINEAR,
+ help_text="scale for x axis",
+ )
+
+ y_scale = models.CharField(
+ max_length=4,
+ choices=ScaleOptions.choices,
+ default=ScaleOptions.LINEAR,
+ help_text="scale for y axis",
+ )
+
+ y2_scale = models.CharField(
+ max_length=4,
+ choices=ScaleOptions.choices,
+ default=ScaleOptions.LINEAR,
+ help_text="scale for rhs y axis",
+ )
+
+ x_unit = models.ForeignKey(
+ "Unit",
+ on_delete=models.PROTECT,
+ related_name="simulation_plots",
+ help_text="unit for x axis",
+ )
+
+ y_unit = models.ForeignKey(
+ "Unit",
+ on_delete=models.PROTECT,
+ related_name="simulation_plots_y",
+ null=True,
+ blank=True,
+ help_text="unit for y axis",
+ )
+
+ y_unit2 = models.ForeignKey(
+ "Unit",
+ on_delete=models.PROTECT,
+ related_name="simulation_plots_y2",
+ null=True,
+ blank=True,
+ help_text="unit for rhs y axis",
+ )
+
+ min = models.FloatField(
+ null=True, blank=True, help_text="lower bound for the y axis"
+ )
+
+ max = models.FloatField(
+ null=True, blank=True, help_text="upper bound for the y axis"
+ )
+
+ min2 = models.FloatField(
+ null=True, blank=True, help_text="lower bound for the rhs y axis"
+ )
+
+ max2 = models.FloatField(
+ null=True, blank=True, help_text="upper bound for the rhs y axis"
+ )
+
+ def get_project(self):
+ return self.simulation.project
+
+
+# model for mapping a variable to a y axis
+class SimulationYAxis(models.Model):
+ plot = models.ForeignKey(
+ "SimulationPlot", on_delete=models.CASCADE, related_name="y_axes"
+ )
+
+ variable = models.ForeignKey(
+ "Variable", on_delete=models.CASCADE, related_name="y_axes"
+ )
+
+ # if true, the variable is plotted on the right y axis
+ right = models.BooleanField(
+ default=False, help_text="True if the variable is plotted on the right y axis"
+ )
+
+
+# model for a slider on the plot. the sliders alter the value of a variable
+# in the model
+class SimulationSlider(models.Model):
+ simulation = models.ForeignKey(
+ "Simulation", on_delete=models.CASCADE, related_name="sliders"
+ )
+
+ variable = models.ForeignKey(
+ "Variable", on_delete=models.CASCADE, related_name="sliders"
+ )
+
+
+class SimulationCxLine(models.Model):
+ plot = models.ForeignKey(
+ "SimulationPlot", on_delete=models.CASCADE, related_name="cx_lines"
+ )
+
+ value = models.FloatField(help_text="value of the line")
diff --git a/pkpdapp/pkpdapp/models/stored.py b/pkpdapp/pkpdapp/models/stored.py
new file mode 100644
index 00000000..447df7de
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/stored.py
@@ -0,0 +1,22 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from django.db import models
+
+
+class StoredModel(models.Model):
+ read_only = models.BooleanField(
+ default=False,
+ help_text='true if object has been stored'
+ )
+ datetime = models.DateTimeField(
+ help_text=(
+ 'datetime the object was stored.'
+ ),
+ null=True, blank=True
+ )
+
+ class Meta:
+ abstract = True
diff --git a/pkpdapp/pkpdapp/models/subject.py b/pkpdapp/pkpdapp/models/subject.py
new file mode 100644
index 00000000..33c8657c
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/subject.py
@@ -0,0 +1,56 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.db import models
+from jsonfield import JSONField
+
+
+class Subject(models.Model):
+ """
+ A subject in a particular dataset.
+ """
+ id_in_dataset = models.IntegerField(help_text='unique id in the dataset')
+ dataset = models.ForeignKey(
+ 'Dataset', on_delete=models.CASCADE,
+ related_name='subjects',
+ help_text='dataset containing this subject'
+ )
+ protocol = models.ForeignKey(
+ 'Protocol', on_delete=models.SET_NULL,
+ related_name='subjects',
+ blank=True, null=True,
+ help_text='dosing protocol for this subject.'
+ )
+ shape = models.IntegerField(
+ default=0,
+ help_text=(
+ 'Shape index associated with this subject. '
+ 'For plotting purposes in the frontend'
+ )
+ )
+ display = models.BooleanField(
+ default=True,
+ help_text=(
+ 'True if this subject will be displayed in the '
+ 'frontend, False otherwise'
+ )
+ )
+ metadata = JSONField(
+ default=dict,
+ help_text='subject metadata',
+ )
+
+ def get_project(self):
+ return self.dataset.get_project()
+
+ class Meta:
+ constraints = [
+ models.UniqueConstraint(fields=['id_in_dataset', 'dataset'],
+ name='subject_dataset_unique'),
+ ]
+
+ def __str__(self):
+ return str(self.id_in_dataset)
diff --git a/pkpdapp/pkpdapp/models/units.py b/pkpdapp/pkpdapp/models/units.py
new file mode 100644
index 00000000..b89e40c1
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/units.py
@@ -0,0 +1,304 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.db import models
+from django.db.models import Q
+import myokit
+
+# https://stackoverflow.com/questions/14711203/perform-a-logical-exclusive-or-on-a-django-q-object
+
+
+class QQ:
+ def __xor__(self, other):
+ not_self = self.clone()
+ not_other = other.clone()
+ not_self.negate()
+ not_other.negate()
+
+ x = self & not_other
+ y = not_self & other
+
+ return x | y
+
+
+class Unit(models.Model):
+ """
+ Model replicating the Unit class from myokit
+
+ Each Unit consists of:
+
+ - A list of seven floats: these are the exponents for the basic
+ SI units: [g, m, s, A, K, cd, mol]. Gram is used instead of the
+ SI defined kilogram to create a more coherent syntax.
+
+ - A multiplier. This includes both quantifiers (such as milli, kilo,
+ Mega etc) and conversion factors (for example 1inch = 2.54cm).
+ Multipliers are specified in powers of 10, e.g. to create an inch
+ use the multiplier log10(2.54).
+ """
+
+ symbol = models.CharField(max_length=50, help_text="symbol for unit display")
+ g = models.FloatField(default=0, help_text="grams exponent")
+ m = models.FloatField(default=0, help_text="meters exponent")
+ s = models.FloatField(default=0, help_text="seconds exponent")
+ A = models.FloatField(default=0, help_text="ampere exponent")
+ K = models.FloatField(default=0, help_text="kelvin exponent")
+ cd = models.FloatField(default=0, help_text="candela exponent")
+ mol = models.FloatField(default=0, help_text="mole exponent")
+ multiplier = models.FloatField(default=0, help_text="multiplier in powers of 10")
+
+ constraints = [
+ models.UniqueConstraint(fields=["symbol"], name="unique unit symbol")
+ ]
+
+ def get_myokit_unit(self):
+ return myokit.Unit(
+ exponents=[self.g, self.m, self.s, self.A, self.K, self.cd, self.mol],
+ multiplier=self.multiplier,
+ )
+
+ def get_project(self):
+ return None
+
+ @staticmethod
+ def get_unit_from_variable(v):
+ unit = v.unit()
+ if unit is None:
+ return None
+ exponents = unit.exponents()
+ multiplier = unit.multiplier_log_10()
+ close_enough = 1e-9
+ close_enough_units = Unit.objects.filter(
+ g__range=(
+ exponents[0] - close_enough,
+ exponents[0] + close_enough,
+ ),
+ m__range=(
+ exponents[1] - close_enough,
+ exponents[1] + close_enough,
+ ),
+ s__range=(
+ exponents[2] - close_enough,
+ exponents[2] + close_enough,
+ ),
+ A__range=(
+ exponents[3] - close_enough,
+ exponents[3] + close_enough,
+ ),
+ K__range=(
+ exponents[4] - close_enough,
+ exponents[4] + close_enough,
+ ),
+ cd__range=(
+ exponents[5] - close_enough,
+ exponents[5] + close_enough,
+ ),
+ mol__range=(
+ exponents[6] - close_enough,
+ exponents[6] + close_enough,
+ ),
+ multiplier__range=(
+ multiplier - close_enough,
+ multiplier + close_enough,
+ ),
+ )
+ if close_enough_units.count() > 0:
+ return close_enough_units[0]
+ else:
+ return Unit.objects.create(
+ symbol=str(unit),
+ g=exponents[0],
+ m=exponents[1],
+ s=exponents[2],
+ A=exponents[3],
+ K=exponents[4],
+ cd=exponents[5],
+ mol=exponents[6],
+ multiplier=multiplier,
+ )
+
+ def is_convertible_to(self, unit, compound=None):
+ try:
+ self.convert_to(unit, compound=compound)
+ except myokit.IncompatibleUnitError:
+ return False
+ return True
+
+ def convert_to(self, unit, compound=None, is_target=False):
+ if unit is None:
+ return 1.0
+ if isinstance(unit, myokit.Unit):
+ myokit_unit = unit
+ else:
+ myokit_unit = unit.get_myokit_unit()
+ helpers = []
+ if compound is not None:
+ if is_target:
+ helpers = [
+ f"{compound.target_molecular_mass} [{compound.target_molecular_mass_unit.symbol}]" # noqa: E501
+ ]
+ else:
+ helpers = [
+ f"{compound.molecular_mass} [{compound.molecular_mass_unit.symbol}]" # noqa: E501
+ ]
+ return myokit.Unit.conversion_factor(
+ self.get_myokit_unit(),
+ myokit_unit,
+ helpers=helpers,
+ ).value()
+
+ @staticmethod
+ def convert_between_myokit_units(
+ from_unit, to_unit, compound=None, is_target=False
+ ):
+ helpers = []
+ if compound is not None:
+ if is_target:
+ helpers = [
+ f"{compound.target_molecular_mass} [{compound.target_molecular_mass_unit.symbol}]" # noqa: E501
+ ]
+ else:
+ helpers = [
+ f"{compound.molecular_mass} [{compound.molecular_mass_unit.symbol}]" # noqa: E501
+ ]
+ return myokit.Unit.conversion_factor(
+ from_unit,
+ to_unit,
+ helpers=helpers,
+ ).value()
+
+ def get_compatible_units(self, compound=None):
+ close_enough = 1e-9
+ if compound is not None:
+ g_is_same = Q(
+ g__range=(
+ self.g - close_enough,
+ self.g + close_enough,
+ )
+ )
+ mol_is_same = Q(
+ mol__range=(
+ self.mol - close_enough,
+ self.mol + close_enough,
+ )
+ )
+ mol_added_to_g = Q(
+ g__range=(
+ self.g + self.mol - close_enough,
+ self.g + self.mol + close_enough,
+ )
+ )
+ g_added_to_mol = Q(
+ mol__range=(
+ self.mol + self.g - close_enough,
+ self.mol + self.g + close_enough,
+ )
+ )
+ no_g = Q(g=0)
+ self_has_g = self.g != 0
+ self_no_g_or_mol = self.g == 0 and self.mol == 0
+ no_mol = Q(mol=0)
+ self_has_mol = self.mol != 0
+ filter = mol_is_same & g_is_same
+ mol_and_g_add_to_zero = Q(mol=1, g=-1) | Q(mol=-1, g=1)
+
+ # take into account that '' is convertible to 'mol/g' or 'g/mol'
+ if self_no_g_or_mol:
+ filter |= mol_and_g_add_to_zero
+ if self_has_mol:
+ filter |= mol_added_to_g & no_mol
+ if self_has_g:
+ filter |= g_added_to_mol & no_g
+ compat_units = Unit.objects.filter(
+ filter,
+ Q(
+ m__range=(
+ self.m - close_enough,
+ self.m + close_enough,
+ )
+ ),
+ Q(
+ s__range=(
+ self.s - close_enough,
+ self.s + close_enough,
+ )
+ ),
+ Q(
+ A__range=(
+ self.A - close_enough,
+ self.A + close_enough,
+ )
+ ),
+ Q(
+ K__range=(
+ self.K - close_enough,
+ self.K + close_enough,
+ )
+ ),
+ Q(
+ cd__range=(
+ self.cd - close_enough,
+ self.cd + close_enough,
+ )
+ ),
+ )
+ return compat_units
+ else:
+ return Unit.objects.filter(
+ Q(
+ g__range=(
+ self.g - close_enough,
+ self.g + close_enough,
+ )
+ ),
+ Q(
+ mol__range=(
+ self.mol - close_enough,
+ self.mol + close_enough,
+ )
+ ),
+ Q(
+ m__range=(
+ self.m - close_enough,
+ self.m + close_enough,
+ )
+ ),
+ Q(
+ s__range=(
+ self.s - close_enough,
+ self.s + close_enough,
+ )
+ ),
+ Q(
+ A__range=(
+ self.A - close_enough,
+ self.A + close_enough,
+ )
+ ),
+ Q(
+ K__range=(
+ self.K - close_enough,
+ self.K + close_enough,
+ )
+ ),
+ Q(
+ cd__range=(
+ self.cd - close_enough,
+ self.cd + close_enough,
+ )
+ ),
+ )
+
+ def is_time_unit(self):
+ return (
+ self.s == 1
+ and self.g == 0
+ and self.m == 0
+ and self.A == 0
+ and self.K == 0
+ and self.cd == 0
+ and self.mol == 0
+ )
diff --git a/pkpdapp/pkpdapp/models/variable.py b/pkpdapp/pkpdapp/models/variable.py
new file mode 100644
index 00000000..2f006f28
--- /dev/null
+++ b/pkpdapp/pkpdapp/models/variable.py
@@ -0,0 +1,400 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from pkpdapp.models import (
+ Unit, CombinedModel,
+ PharmacokineticModel, PharmacodynamicModel,
+ StoredModel, Protocol,
+)
+import numpy as np
+from django.db.models import Q
+from django.db import models
+import logging
+logger = logging.getLogger(__name__)
+
+
+class Variable(StoredModel):
+ """
+ A single variable for a mechanistic model.
+ """
+ is_public = models.BooleanField(default=False)
+ lower_bound = models.FloatField(
+ blank=True, null=True,
+ help_text='lowest possible value for this variable'
+ )
+ upper_bound = models.FloatField(
+ blank=True, null=True,
+ help_text='largest possible value for this variable'
+ )
+ default_value = models.FloatField(
+ default=1,
+ help_text='default value for this variable'
+ )
+
+ is_log = models.BooleanField(
+ default=False,
+ help_text=(
+ 'True if default_value is stored as '
+ 'the log of this value'
+ )
+ )
+
+ name = models.CharField(max_length=100, help_text='name of the variable')
+ description = models.TextField(
+ blank=True, null=True,
+ help_text='description of the variable'
+ )
+ binding = models.CharField(
+ max_length=100,
+ help_text='myokit binding of the variable (e.g. time)',
+ blank=True, null=True,
+ )
+
+ qname = models.CharField(
+ max_length=200, help_text='fully qualitifed name of the variable')
+
+ unit = models.ForeignKey(
+ Unit, on_delete=models.PROTECT,
+ blank=True, null=True,
+ help_text=(
+ 'variable values are in this unit '
+ '(note this might be different from the unit '
+ 'in the stored sbml)'
+ )
+ )
+
+ unit_symbol = models.CharField(
+ max_length=20, blank=True, null=True,
+ help_text=(
+ 'if unit is None then this is the unit of this '
+ 'variable as a string'
+ )
+ )
+
+ constant = models.BooleanField(
+ default=True,
+ help_text=(
+ 'True for a constant variable of the model, '
+ 'i.e. a parameter. False if non-constant, '
+ 'i.e. an output of the model (default is True)'
+ )
+ )
+ state = models.BooleanField(
+ default=False,
+ help_text=(
+ 'True if it is a state variable of the model '
+ 'and has an initial condition parameter '
+ '(default is False)'
+ )
+ )
+
+ color = models.IntegerField(
+ default=0,
+ help_text=(
+ 'Color index associated with this variable. '
+ 'For display purposes in the frontend'
+ )
+ )
+ display = models.BooleanField(
+ default=True,
+ help_text=(
+ 'True if this variable will be displayed in the '
+ 'frontend, False otherwise'
+ )
+ )
+ axis = models.BooleanField(
+ default=False,
+ help_text=(
+ 'False/True if biomarker type displayed on LHS/RHS axis'
+ )
+ )
+
+ pd_model = models.ForeignKey(
+ PharmacodynamicModel,
+ blank=True, null=True,
+ on_delete=models.CASCADE,
+ related_name='variables',
+ help_text='pharmacodynamic model'
+ )
+ pk_model = models.ForeignKey(
+ PharmacokineticModel,
+ blank=True, null=True,
+ on_delete=models.CASCADE,
+ related_name='variables',
+ help_text='pharmacokinetic model'
+ )
+ dosed_pk_model = models.ForeignKey(
+ CombinedModel,
+ blank=True, null=True,
+ on_delete=models.CASCADE,
+ related_name='variables',
+ help_text='dosed pharmacokinetic model'
+ )
+
+ protocol = models.ForeignKey(
+ Protocol,
+ on_delete=models.SET_NULL,
+ related_name='variables',
+ blank=True, null=True,
+ help_text='dosing protocol'
+ )
+
+ class Meta:
+ constraints = [
+ models.CheckConstraint(
+ check=(
+ (Q(is_log=True) & Q(lower_bound__gt=0)) |
+ Q(is_log=False)
+ ),
+ name=(
+ '%(class)s: log scale must have a lower '
+ 'bound greater than zero'
+ )
+ ),
+ models.CheckConstraint(
+ check=(
+ (Q(pk_model__isnull=True) &
+ Q(dosed_pk_model__isnull=True) &
+ Q(pd_model__isnull=False)) |
+ (Q(pk_model__isnull=False) &
+ Q(dosed_pk_model__isnull=True) &
+ Q(pd_model__isnull=True)) |
+ (Q(pk_model__isnull=True) &
+ Q(dosed_pk_model__isnull=False) &
+ Q(pd_model__isnull=True))
+ ),
+ name='%(class)s: variable must belong to a model'
+ )
+ ]
+
+ def get_model(self):
+ model = None
+ if self.pd_model:
+ model = self.pd_model
+ if self.dosed_pk_model:
+ model = self.dosed_pk_model
+ if self.pk_model:
+ model = self.pk_model
+ return model
+
+ def get_default_value(self):
+ if self.is_log:
+ return np.exp(self.default_value)
+ else:
+ return self.default_value
+
+ def get_project(self):
+ model = self.get_model()
+ if model is not None:
+ return model.get_project()
+ else:
+ return None
+
+ @staticmethod
+ def get_variable_pk(model, myokit_variable):
+ num_variables = Variable.objects.filter(
+ pk_model=model,
+ ).count()
+ variables = Variable.objects.filter(
+ qname=myokit_variable.qname(),
+ pk_model=model,
+ )
+ found_variable = Variable._find_close_variable(
+ myokit_variable, variables,
+ compound=model.get_project().compound
+ )
+ if found_variable is not None:
+ return variables[0]
+ else:
+ state = myokit_variable.is_state()
+ if state:
+ value = myokit_variable.state_value()
+ else:
+ value = myokit_variable.value()
+ qname = myokit_variable.qname()
+ return Variable.objects.create(
+ name=myokit_variable.name(),
+ qname=qname,
+ default_value=value,
+ description=myokit_variable.meta.get('desc', ''),
+ binding=myokit_variable.binding(),
+ lower_bound=None,
+ upper_bound=None,
+ constant=myokit_variable.is_constant(),
+ state=state,
+ unit=Unit.get_unit_from_variable(myokit_variable),
+ pk_model=model,
+ color=num_variables,
+ display=myokit_variable.name() != 'time',
+ )
+
+ @staticmethod
+ def _find_close_variable(myokit_variable, variables, compound=None):
+ logger.debug('Looking for variable: {} [{}]'.format(
+ myokit_variable, myokit_variable.unit()
+ ))
+ found = None
+ for i, v in enumerate(variables):
+ # todo check if units are compatible...
+ if v.unit is None:
+ logger.debug('\tchecking variable: {}'.format(v.qname))
+ else:
+ logger.debug('\tchecking variable: {} [{}]'.format(
+ v.qname, v.unit.symbol
+ ))
+ if v.unit is None:
+ if myokit_variable.unit() is None:
+ found = i
+ elif (
+ myokit_variable.unit() is not None and
+ v.unit.is_convertible_to(
+ myokit_variable.unit(), compound=compound
+ )
+ ):
+ found = i
+ if found is not None:
+ logger.debug('Found variable: {}'.format(variables[found]))
+ return variables[found]
+ return None
+
+ @staticmethod
+ def get_variable_pd(model, myokit_variable):
+ num_variables = Variable.objects.filter(
+ pd_model=model,
+ ).count()
+ variables = Variable.objects.filter(
+ qname=myokit_variable.qname(),
+ pd_model=model,
+ )
+ project = model.get_project()
+ compound = None
+ if project is not None:
+ compound = project.compound
+ found_variable = Variable._find_close_variable(
+ myokit_variable, variables,
+ compound=compound
+ )
+ if found_variable is not None:
+ return variables[0]
+ else:
+ state = myokit_variable.is_state()
+ if state:
+ value = myokit_variable.state_value()
+ else:
+ value = myokit_variable.value()
+ qname = myokit_variable.qname()
+ return Variable.objects.create(
+ name=myokit_variable.name(),
+ qname=qname,
+ description=myokit_variable.meta.get('desc', ''),
+ constant=myokit_variable.is_constant(),
+ binding=myokit_variable.binding(),
+ default_value=value,
+ lower_bound=None,
+ upper_bound=None,
+ state=state,
+ unit=Unit.get_unit_from_variable(myokit_variable),
+ pd_model=model,
+ color=num_variables,
+ display=myokit_variable.name() != 'time',
+ )
+
+ @staticmethod
+ def get_variable_dosed_pk(model, myokit_variable):
+ num_variables = Variable.objects.filter(
+ dosed_pk_model=model,
+ ).count()
+ variables = Variable.objects.filter(
+ qname=myokit_variable.qname(),
+ dosed_pk_model=model,
+ )
+ compound = None
+ project = model.get_project()
+ if project is not None:
+ compound = project.compound
+ found_variable = Variable._find_close_variable(
+ myokit_variable, variables,
+ compound=compound
+ )
+ if found_variable is not None:
+ return variables[0]
+ else:
+ # lower and upper bounds for library models
+ lower = None
+ upper = None
+ if model.is_library_model:
+ if myokit_variable.qname() == 'PDCompartment.Imax':
+ upper = 1.0
+ elif myokit_variable.qname() == 'PKCompartment.F':
+ upper = 1.0
+ elif myokit_variable.qname() == 'PDCompartment.FE':
+ upper = 1.0
+ elif myokit_variable.qname() == 'PDCompartment.Emax':
+ lower = 1.0
+ state = myokit_variable.is_state()
+ if state:
+ value = myokit_variable.state_value()
+ else:
+ value = myokit_variable.value()
+ qname = myokit_variable.qname()
+ return Variable.objects.create(
+ name=myokit_variable.name(),
+ qname=qname,
+ description=myokit_variable.meta.get('desc', ''),
+ constant=myokit_variable.is_constant(),
+ default_value=value,
+ binding=myokit_variable.binding(),
+ lower_bound=lower,
+ upper_bound=upper,
+ state=state,
+ unit=Unit.get_unit_from_variable(myokit_variable),
+ dosed_pk_model=model,
+ color=num_variables,
+ display=myokit_variable.name() != 'time',
+ )
+
+ @staticmethod
+ def get_variable(model, myokit_variable):
+ if isinstance(model, PharmacokineticModel):
+ return Variable.get_variable_pk(model, myokit_variable)
+ elif isinstance(model, CombinedModel):
+ return Variable.get_variable_dosed_pk(model, myokit_variable)
+ elif isinstance(model, PharmacodynamicModel):
+ return Variable.get_variable_pd(model, myokit_variable)
+ else:
+ raise RuntimeError(
+ 'create_variable got unexpected model type {}'
+ .format(type(model)),
+ )
+
+ def create_stored_variable(self, stored_model):
+ stored_variable_kwargs = {
+ 'name': self.name,
+ 'qname': self.qname,
+ 'description': self.description,
+ 'unit': self.unit,
+ 'is_public': self.is_public,
+ 'binding': self.binding,
+ 'lower_bound': self.lower_bound,
+ 'upper_bound': self.upper_bound,
+ 'default_value': self.default_value,
+ 'is_log': self.is_log,
+ 'axis': self.axis,
+ 'display': self.display,
+ 'color': self.color,
+ 'state': self.state,
+ 'unit_symbol': self.unit_symbol,
+ 'constant': self.constant,
+ 'read_only': True,
+ 'protocol': (
+ self.protocol.create_stored_protocol()
+ if self.protocol is not None else None
+ ),
+ }
+ if isinstance(stored_model, PharmacodynamicModel):
+ stored_variable_kwargs['pd_model'] = stored_model
+ elif isinstance(stored_model, CombinedModel):
+ stored_variable_kwargs['dosed_pk_model'] = stored_model
+ return Variable.objects.create(**stored_variable_kwargs)
diff --git a/pkpdapp/pkpdapp/settings.py b/pkpdapp/pkpdapp/settings.py
new file mode 100644
index 00000000..d5e276d9
--- /dev/null
+++ b/pkpdapp/pkpdapp/settings.py
@@ -0,0 +1,419 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+"""
+Django settings for pkpdapp project.
+
+Generated by 'django-admin startproject' using Django 3.0.5.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/topics/settings/.
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/3.0/ref/settings/.
+"""
+
+import os
+import dj_database_url
+import ldap
+from django_auth_ldap.config import LDAPSearch
+
+# Set BASE_DIR to two directories up
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# setup automatic pk column for models
+DEFAULT_AUTO_FIELD = 'django.db.models.AutoField'
+
+LOGGING = {
+ 'version': 1,
+ 'disable_existing_loggers': False,
+ 'handlers': {
+ 'console': {
+ 'class': 'logging.StreamHandler',
+ 'level': 'DEBUG',
+ 'formatter': 'simple'
+ },
+ 'file': {
+ 'class': 'logging.handlers.RotatingFileHandler',
+ 'filename': os.path.join(BASE_DIR, 'logfile.log'),
+ 'maxBytes': 1024 * 1024 * 5, # 5 MB
+ 'backupCount': 5,
+ 'level': 'DEBUG',
+ 'formatter': 'verbose'
+ }
+ },
+ 'loggers': {
+ 'django': {
+ 'handlers': ['console', 'file'],
+ 'level': 'INFO',
+ 'propagate': False,
+ },
+ 'pkpdapp': {
+ 'handlers': ['console', 'file'],
+ 'level': 'DEBUG',
+ 'propagate': False,
+ },
+ },
+ 'formatters': {
+ 'simple': {
+ 'format': '%(levelname)s %(message)s'
+ },
+ 'verbose': {
+ 'format': '%(asctime)s %(levelname)s %(module)s %(process)d %(thread)d %(message)s' # noqa: E501
+ }
+ }
+}
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
+
+SECRET_KEY = os.environ.get("SECRET_KEY", default='foo')
+
+DEBUG = int(os.environ.get("DEBUG", default=0))
+
+ALLOWED_HOSTS = [os.environ.get('HOST_NAME', 'localhost'), '127.0.0.1']
+
+if DEBUG:
+ ALLOWED_HOSTS.append('testserver')
+
+
+# Application definition - to use any of those you need to run `manage.py
+# migrate` first
+
+INSTALLED_APPS = [
+ # standard Django apps
+ 'django.contrib.admin',
+ 'django.contrib.admindocs',
+ 'django.contrib.auth',
+ 'django.contrib.contenttypes',
+ 'django.contrib.sessions',
+ 'django.contrib.messages',
+ 'django.contrib.staticfiles',
+
+ # external apps
+ 'dpd_static_support',
+ 'django_extensions',
+ 'djoser',
+ 'rest_framework',
+ 'rest_framework.authtoken',
+ 'corsheaders',
+ 'drf_spectacular',
+
+ # internal apps
+ 'pkpdapp',
+]
+
+use_ldap = bool(int(os.environ.get('AUTH_LDAP_USE', '0')))
+if use_ldap:
+ AUTHENTICATION_BACKENDS = [
+ "django_auth_ldap.backend.LDAPBackend",
+ "django.contrib.auth.backends.ModelBackend",
+ ]
+ AUTH_LDAP_SERVER_URI = os.environ.get(
+ 'AUTH_LDAP_SERVER_URI',
+ 'ldap://ldap.forumsys.com:389'
+ )
+
+ use_direct_bind = bool(int(os.environ.get('AUTH_LDAP_DIRECT_BIND', '0')))
+ if use_direct_bind:
+ AUTH_LDAP_USER_DN_TEMPLATE = os.environ.get(
+ 'AUTH_LDAP_BIND_DN_TEMPLATE',
+ 'uid=%(user)s,dc=example,dc=com'
+ )
+ else:
+ AUTH_LDAP_BIND_DN = os.environ.get(
+ 'AUTH_LDAP_BIND_DN',
+ 'cn=read-only-admin,dc=example,dc=com'
+ )
+ AUTH_LDAP_BIND_PASSWORD = os.environ.get(
+ 'AUTH_LDAP_BIND_PASSWORD',
+ 'password'
+ )
+ AUTH_LDAP_USER_SEARCH = LDAPSearch(
+ os.environ.get(
+ 'AUTH_LDAP_SEARCH_BASE',
+ 'ou=mathematicians,dc=example,dc=com'
+ ),
+ ldap.SCOPE_SUBTREE,
+ os.environ.get(
+ 'AUTH_LDAP_SEARCH_FILTER',
+ "(uid=%(user)s)"
+ ),
+ )
+
+DJOSER = {
+ 'PASSWORD_RESET_CONFIRM_URL': 'reset-password/{uid}/{token}',
+ 'ACTIVATION_URL': 'activate/{uid}/{token}',
+ 'SEND_ACTIVATION_EMAIL': True,
+ 'SEND_CONFIRMATION_EMAIL': True,
+ 'PASSWORD_CHANGED_EMAIL_CONFIRMATION': True,
+ 'SERIALIZERS': {},
+ 'PERMISSIONS': {
+ 'activation': ['rest_framework.permissions.AllowAny'],
+ 'password_reset': ['rest_framework.permissions.AllowAny'],
+ 'password_reset_confirm': ['rest_framework.permissions.AllowAny'],
+ 'set_password': ['djoser.permissions.CurrentUserOrAdmin'],
+ 'username_reset': ['rest_framework.permissions.AllowAny'],
+ 'username_reset_confirm': ['rest_framework.permissions.AllowAny'],
+ 'set_username': ['djoser.permissions.CurrentUserOrAdmin'],
+ 'user_create': ['rest_framework.permissions.AllowAny'],
+ 'user_delete': ['djoser.permissions.CurrentUserOrAdmin'],
+ 'user': ['djoser.permissions.CurrentUserOrAdmin'],
+ 'user_list': ['djoser.permissions.CurrentUserOrAdmin'],
+ 'token_create': ['rest_framework.permissions.AllowAny'],
+ 'token_destroy': ['rest_framework.permissions.IsAuthenticated'],
+ },
+}
+
+
+# django rest framework library
+REST_FRAMEWORK = {
+ 'DEFAULT_RENDERER_CLASSES': [
+ 'rest_framework.renderers.JSONRenderer',
+ ],
+ 'DEFAULT_AUTHENTICATION_CLASSES': [
+ 'rest_framework.authentication.SessionAuthentication',
+ ],
+ 'DEFAULT_PERMISSION_CLASSES': [
+ 'rest_framework.permissions.IsAuthenticated',
+ ],
+ 'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema',
+}
+
+SPECTACULAR_SETTINGS = {
+ 'TITLE': 'PKPDApp API',
+ 'DESCRIPTION': 'The API for the PKPDApp',
+ 'VERSION': '1.0.0',
+ 'SERVE_INCLUDE_SCHEMA': False,
+}
+
+
+CRISPY_TEMPLATE_PACK = 'bootstrap4'
+
+MARKDOWNIFY_MARKDOWN_EXTENSIONS = [
+ 'mdx_math',
+]
+
+MARKDOWNIFY_WHITELIST_TAGS = [
+ 'a',
+ 'abbr',
+ 'acronym',
+ 'b',
+ 'blockquote',
+ 'em',
+ 'i',
+ 'li',
+ 'ol',
+ 'p',
+ 'strong',
+ 'ul',
+ 'h',
+ 'script',
+]
+
+MARKDOWNIFY_WHITELIST_ATTRS = [
+ 'href',
+ 'src',
+ 'alt',
+ 'type',
+]
+
+MARKDOWNIFY_WHITELIST_STYLES = [
+ 'color',
+ 'font-weight',
+]
+
+MIDDLEWARE = [
+ "corsheaders.middleware.CorsMiddleware",
+ 'django.middleware.security.SecurityMiddleware',
+ 'whitenoise.middleware.WhiteNoiseMiddleware',
+
+ 'django.contrib.sessions.middleware.SessionMiddleware',
+ 'django.middleware.common.CommonMiddleware',
+ 'django.middleware.csrf.CsrfViewMiddleware',
+ 'django.contrib.auth.middleware.AuthenticationMiddleware',
+ 'django.contrib.messages.middleware.MessageMiddleware',
+ 'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+CORS_ALLOWED_ORIGINS = [
+ "http://127.0.0.1:3000",
+ "http://127.0.0.1:3001",
+ "http://127.0.0.1:3002",
+ "http://127.0.0.1:3003",
+ "http://127.0.0.1:3004",
+ "http://localhost:3000",
+ "http://" + os.environ.get('HOST_NAME', 'bamad.herokuapp.com')
+]
+
+CORS_ALLOW_ALL_ORIGINS = True
+
+CORS_EXPOSE_HEADERS = ['Content-Type', 'X-CSRFToken']
+CORS_ALLOW_CREDENTIALS = True
+
+ROOT_URLCONF = 'pkpdapp.urls'
+
+TEMPLATES = [
+ {
+ 'BACKEND': 'django.template.backends.django.DjangoTemplates',
+ 'DIRS': [os.path.join(BASE_DIR, 'pkpdapp', 'templates')],
+ 'APP_DIRS': True,
+ 'OPTIONS': {
+ 'context_processors': [
+ 'django.template.context_processors.debug',
+ 'django.template.context_processors.request',
+ 'django.contrib.auth.context_processors.auth',
+ 'django.contrib.messages.context_processors.messages',
+ ],
+ },
+ },
+]
+
+
+X_FRAME_OPTIONS = 'SAMEORIGIN'
+
+# WSGI_APPLICATION = 'bamad.wsgi.application'
+
+# authentication cookie settings
+CSRF_COOKIE_SAMESITE = 'Lax'
+SESSION_COOKIE_SAMESITE = 'Lax'
+CSRF_COOKIE_HTTPONLY = False
+SESSION_COOKIE_HTTPONLY = True
+
+# PROD ONLY
+# CSRF_COOKIE_SECURE = True
+# SESSION_COOKIE_SECURE = True
+
+
+WSGI_APPLICATION = 'pkpdapp.wsgi.application'
+
+
+# Database
+# https://docs.djangoproject.com/en/3.0/ref/settings/#databases
+DATABASES = {
+ 'default': {
+ 'ENGINE': 'django.db.backends.sqlite3',
+ 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
+ 'OPTIONS': {
+ # 'timeout': 20,
+ }
+ }
+}
+
+DATABASE_URL = os.environ.get('DATABASE_URL')
+db_from_env = dj_database_url.config(
+ default=DATABASE_URL, conn_max_age=500, ssl_require=False
+)
+DATABASES['default'].update(db_from_env)
+
+
+# Password validation
+# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+ {
+ 'NAME':
+ 'django.contrib.auth.password_validation.'
+ 'UserAttributeSimilarityValidator',
+ },
+ {
+ 'NAME': 'django.contrib.auth.password_validation.'
+ 'MinimumLengthValidator',
+ },
+ {
+ 'NAME': 'django.contrib.auth.password_validation.'
+ 'CommonPasswordValidator',
+ },
+ {
+ 'NAME': 'django.contrib.auth.password_validation.'
+ 'NumericPasswordValidator',
+ },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/3.0/topics/i18n/
+
+LANGUAGE_CODE = 'en-us'
+
+TIME_ZONE = 'UTC'
+
+USE_I18N = True
+
+USE_L10N = True
+
+USE_TZ = True
+
+# Media files (such as data sets and model files)
+MEDIA_URL = '/media/'
+MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/3.0/howto/static-files/
+STATIC_URL = '/static/'
+STATIC_ROOT = os.path.join(BASE_DIR, 'static')
+
+STATICFILES_DIRS = [
+]
+
+# Staticfiles finders for locating dash app assets and related files
+STATICFILES_FINDERS = [
+ # Django default finders
+ 'django.contrib.staticfiles.finders.FileSystemFinder',
+ 'django.contrib.staticfiles.finders.AppDirectoriesFinder',
+]
+
+# Forever cachable files and compression support
+STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
+
+
+# Redirect to home URL after login (Default redirects to /accounts/profile/)
+LOGIN_REDIRECT_URL = '/'
+
+
+EMAIL_HOST = os.environ.get("EMAIL_HOST", default=None)
+if EMAIL_HOST is None:
+ EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
+else:
+ EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
+
+EMAIL_PORT = os.environ.get("EMAIL_PORT", default='foo')
+EMAIL_HOST_USER = os.environ.get("EMAIL_HOST_USER", default='foo')
+EMAIL_HOST_PASSWORD = os.environ.get("EMAIL_HOST_PASSWORD", default='foo')
+DEFAULT_FROM_EMAIL = os.environ.get("DEFAULT_FROM_EMAIL",
+ default='webmaster@localhost')
+
+CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
+ 'LOCATION': '127.0.0.1:11211',
+ }
+}
+
+DEFAULT_FROM_EMAIL = os.environ.get("DEFAULT_FROM_EMAIL",
+ default='webmaster@localhost')
+
+CLOUDAMQP_URL = os.environ.get("CLOUDAMQP_URL", default=None)
+if CLOUDAMQP_URL is None:
+ CELERY_BROKER_URL = [
+ 'amqp://',
+ 'amqp://{}:{}@rabbitmq:5672'.format(
+ os.environ.get("RABBITMQ_DEFAULT_USER",
+ default='guest'),
+ os.environ.get("RABBITMQ_DEFAULT_PASS",
+ default='guest')
+ )
+ ]
+else:
+ CELERY_BROKER_URL = CLOUDAMQP_URL
+
+CELERY_BROKER_TRANSPORT_OPTIONS = {
+ 'max_retries': 3,
+ 'interval_start': 0,
+ 'interval_step': 0.2,
+ 'interval_max': 0.5,
+}
diff --git a/pkpdapp/pkpdapp/signals/__init__.py b/pkpdapp/pkpdapp/signals/__init__.py
new file mode 100644
index 00000000..c181e488
--- /dev/null
+++ b/pkpdapp/pkpdapp/signals/__init__.py
@@ -0,0 +1,7 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from .add_profile_on_user_save import add_profile_on_user_save # noqa: F401
diff --git a/pkpdapp/pkpdapp/signals/add_profile_on_user_save.py b/pkpdapp/pkpdapp/signals/add_profile_on_user_save.py
new file mode 100644
index 00000000..e2217709
--- /dev/null
+++ b/pkpdapp/pkpdapp/signals/add_profile_on_user_save.py
@@ -0,0 +1,12 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from pkpdapp.models import Profile
+
+
+def add_profile_on_user_save(sender, **kwargs):
+ if kwargs['created']:
+ Profile.objects.create(user=kwargs['instance']).save()
diff --git a/pkpdapp/pkpdapp/tasks.py b/pkpdapp/pkpdapp/tasks.py
new file mode 100644
index 00000000..4f23b12b
--- /dev/null
+++ b/pkpdapp/pkpdapp/tasks.py
@@ -0,0 +1,28 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from celery import shared_task
+
+from pkpdapp.models import (
+ Inference, InferenceMixin
+)
+
+
+@shared_task
+def run_inference(inference_id):
+ inference = Inference.objects.get(id=inference_id)
+
+ print('task', inference.number_of_iterations, inference_id)
+ for ll in inference.log_likelihoods.all():
+ print('LL', ll.id, ll.name, ll.biomarker_type)
+
+ # create the mixin object to run the inference
+ inference_mixin = InferenceMixin(inference)
+ inference_mixin.run_inference()
+
+ # remove task id to indicate that we're finished
+ inference.task_id = None
+ inference.save()
diff --git a/pkpdapp/pkpdapp/tests/__init__.py b/pkpdapp/pkpdapp/tests/__init__.py
new file mode 100644
index 00000000..c062f5b8
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/__init__.py
@@ -0,0 +1,14 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+# flake8: noqa f401
+from .utils import create_pd_inference
+import os
+import django
+
+
+django.setup()
+dummy = ""
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'pkpdapp.settings')
diff --git a/pkpdapp/pkpdapp/tests/test_models/__init__.py b/pkpdapp/pkpdapp/tests/test_models/__init__.py
new file mode 100644
index 00000000..d0505307
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/__init__.py
@@ -0,0 +1,5 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_biomarker_type.py b/pkpdapp/pkpdapp/tests/test_models/test_biomarker_type.py
new file mode 100644
index 00000000..e02f4b10
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_biomarker_type.py
@@ -0,0 +1,135 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+from django.test import TestCase
+from pkpdapp.models import (
+ Dataset,
+ BiomarkerType,
+ Biomarker,
+ Unit,
+ Subject,
+)
+from django.utils import timezone
+from django.db.utils import IntegrityError
+import numpy as np
+
+
+class TestBiomarkerTypeModel(TestCase):
+ def setUp(self):
+ self.dataset = Dataset.objects.create(
+ name='my_cool_dataset',
+ datetime=timezone.now(),
+ description='description for my cool biomarker',
+ )
+
+ self.unit = Unit.objects.get(symbol='mg')
+ self.time_unit = Unit.objects.get(symbol='h')
+ self.biomarker_type = BiomarkerType.objects.create(
+ name='my_cool_biomarker_type',
+ description='description for my cool biomarker_type',
+ dataset=self.dataset,
+ stored_unit=self.unit,
+ display_unit=self.unit,
+ stored_time_unit=self.time_unit,
+ display_time_unit=self.time_unit,
+ )
+ self.biomarker_type2 = BiomarkerType.objects.create(
+ name='my_cool_biomarker_type 2',
+ description='description for my cool biomarker_type',
+ dataset=self.dataset,
+ stored_unit=self.unit,
+ display_unit=self.unit,
+ stored_time_unit=self.time_unit,
+ display_time_unit=self.time_unit,
+ )
+ self.subjects = [
+ Subject.objects.create(
+ id_in_dataset=1,
+ dataset=self.dataset,
+ ),
+ Subject.objects.create(
+ id_in_dataset=2,
+ dataset=self.dataset,
+ ),
+ ]
+
+ self.values = [0, 1, 2, 3]
+ self.times = [0, 2, 4, 6]
+ self.biomarker_subjects = [
+ self.subjects[0].id, self.subjects[0].id, self.subjects[0].id,
+ self.subjects[1].id
+ ]
+ self.biomarkers = [
+ Biomarker.objects.create(
+ time=time,
+ subject=self.subjects[0],
+ biomarker_type=self.biomarker_type,
+ value=value
+ ) for value, time in zip(self.values[:-1], self.times[:-1])
+ ]
+ self.biomarkers.append(
+ Biomarker.objects.create(
+ time=self.times[-1],
+ subject=self.subjects[1],
+ biomarker_type=self.biomarker_type,
+ value=self.values[-1]
+ )
+ )
+
+ def test_biomarker_type_creation(self):
+ self.assertTrue(
+ isinstance(self.biomarker_type, BiomarkerType)
+ )
+
+ def test_str(self):
+ self.assertEqual(
+ str(self.biomarker_type), "my_cool_biomarker_type"
+ )
+
+ def test_requires_a_unit(self):
+ with self.assertRaises(IntegrityError):
+ BiomarkerType.objects.create(
+ name='my_cool_biomarker_type2',
+ description='description',
+ dataset=self.dataset,
+ )
+
+ def test_unit_conversion(self):
+ new_unit = Unit.objects.get(symbol='g')
+ old_values = self.biomarker_type.data()['values']
+ self.biomarker_type.display_unit = new_unit
+ self.biomarker_type.save()
+ new_values = self.biomarker_type.data()['values']
+ np.testing.assert_array_equal(
+ old_values, 1e3 * new_values
+ )
+
+ def test_as_pandas(self):
+ df = self.biomarker_type.data()
+ np.testing.assert_array_equal(
+ df['values'], np.array(self.values)
+ )
+ np.testing.assert_array_equal(
+ df['times'], np.array(self.times)
+ )
+ np.testing.assert_array_equal(
+ df['subjects'], np.array(self.biomarker_subjects)
+ )
+
+ df = self.biomarker_type.data(first_time_only=True)
+
+ np.testing.assert_array_equal(
+ df['times'], [self.times[0], self.times[3]]
+ )
+ np.testing.assert_array_equal(
+ df['values'], [self.values[0], self.values[3]]
+ )
+
+ def test_empty_data(self):
+ df = self.biomarker_type2.data()
+ for key in ['values', 'times', 'subjects']:
+ self.assertEqual(len(df[key]), 0)
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_dataset.py b/pkpdapp/pkpdapp/tests/test_models/test_dataset.py
new file mode 100644
index 00000000..db9a7825
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_dataset.py
@@ -0,0 +1,64 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+from django.test import TestCase
+from pkpdapp.models import (
+ Dataset,
+ BiomarkerType,
+ Biomarker,
+ Unit,
+ Subject,
+)
+from django.utils import timezone
+
+
+class TestBiomarkerTypeModel(TestCase):
+ def setUp(self):
+ self.dataset = Dataset.objects.create(
+ name='my_cool_dataset',
+ datetime=timezone.now(),
+ description='description for my cool biomarker',
+ )
+
+ self.unit = Unit.objects.get(symbol='mg')
+ self.time_unit = Unit.objects.get(symbol='h')
+ self.biomarker_type = BiomarkerType.objects.create(
+ name='my_cool_biomarker_type',
+ description='description for my cool biomarker_type',
+ dataset=self.dataset,
+ stored_unit=self.unit,
+ display_unit=self.unit,
+ stored_time_unit=self.time_unit,
+ display_time_unit=self.time_unit,
+ )
+ self.subject = Subject.objects.create(
+ id_in_dataset=1,
+ dataset=self.dataset,
+ )
+ self.values = [0, 1, 2]
+ self.times = [0, 2, 4]
+ self.subjects = [self.subject.id, self.subject.id, self.subject.id]
+ self.biomarkers = [
+ Biomarker.objects.create(
+ time=time,
+ subject=self.subject,
+ biomarker_type=self.biomarker_type,
+ value=value
+ ) for value, time in zip(self.values, self.times)
+ ]
+
+ def test_dataset_creation(self):
+ self.assertTrue(
+ isinstance(self.dataset, Dataset)
+ )
+
+ def test_dataset_deletion(self):
+ self.dataset.delete()
+ with self.assertRaises(BiomarkerType.DoesNotExist):
+ BiomarkerType.objects.get(id=self.biomarker_type.id)
+ with self.assertRaises(Biomarker.DoesNotExist):
+ Biomarker.objects.get(id=self.biomarkers[0].id)
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_inference.py b/pkpdapp/pkpdapp/tests/test_models/test_inference.py
new file mode 100644
index 00000000..59abcc67
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_inference.py
@@ -0,0 +1,52 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from django.test import TestCase
+from pkpdapp.models import (
+ InferenceResult, InferenceMixin,
+ InferenceFunctionResult
+)
+import numpy as np
+from pkpdapp.tests import create_pd_inference
+
+
+class TestInferenceSerializer(TestCase):
+ def setUp(self):
+ self.inference, log_likelihood, _, _, \
+ self.model, _ = create_pd_inference(
+ sampling=False)
+
+ # set uniform prior on first param, except amounts
+ self.param = log_likelihood.parameters.first()
+ self.param.set_uniform_prior(0.0, 2.0)
+
+ def test_run_inference(self):
+ self.inference.run_inference(test=True)
+ self.assertEqual(self.inference.name, 'bob')
+ self.assertEqual(self.inference.log_likelihoods.count(), 8)
+
+ def test_set_variables_from_inference(self):
+ inference_mixin = InferenceMixin(self.inference)
+ inference_mixin.run_inference()
+ chains = self.inference.chains.all()
+ results = np.array(InferenceResult.objects.filter(
+ chain__in=chains
+ ).order_by(
+ 'iteration', 'chain'
+ ).values_list('value', flat=True))
+ fresults = np.array(InferenceFunctionResult.objects.filter(
+ chain__in=chains
+ ).order_by(
+ 'iteration', 'chain'
+ ).values_list('value', flat=True))
+ max_value = results[np.argmax(fresults)]
+
+ fitted_variable = self.param.variable
+ old_value = fitted_variable.default_value
+ self.model.set_variables_from_inference(self.inference)
+ fitted_variable.refresh_from_db()
+ new_value = fitted_variable.default_value
+ self.assertEqual(new_value, max_value)
+ self.assertNotEqual(old_value, new_value)
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_inference_mixin.py b/pkpdapp/pkpdapp/tests/test_models/test_inference_mixin.py
new file mode 100644
index 00000000..a7d0f370
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_inference_mixin.py
@@ -0,0 +1,340 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.test import TestCase
+import numpy as np
+from pkpdapp.models import (
+ LogLikelihood,
+ InferenceMixin, InferenceChain, InferenceResult,
+ InferenceFunctionResult, LogLikelihoodParameter,
+)
+from pkpdapp.tests import create_pd_inference
+from django.core.cache import cache
+
+
+class TestInferenceMixinSingleOutputSampling(TestCase):
+ def setUp(self):
+ # ensure we've got nothing in the cache
+ cache._cache.flush_all()
+
+ self.inference, log_likelihood, _, _, _, _ = create_pd_inference(True)
+
+ # set uniform prior on everything, except amounts
+ for param in log_likelihood.parameters.all():
+ param.set_uniform_prior(0.0, 2.0)
+
+ # 'run' inference to create copies of models
+ self.inference.run_inference(test=True)
+
+ # create mixin object
+ self.inference_mixin = InferenceMixin(self.inference)
+
+ def test_objective_functions(self):
+ # Test log-posterior
+ log_posterior = self.inference_mixin._pints_log_posterior
+ log_posterior(
+ log_posterior.to_search([1.3, 0.5, 1.1, 0.9, 1.2, 1])
+ )
+
+ def test_inference_runs(self):
+ # tests that inference runs and writes results to db
+
+ self.inference_mixin.run_inference()
+
+ chains = self.inference_mixin.inference.chains.all()
+ self.assertEqual(len(chains), 3)
+ for chain in chains:
+ priors = self.inference_mixin._priors
+ fun_res = chain.inference_function_results
+ f_vals = fun_res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ self.assertEqual(len(f_vals), 11)
+ p_vals_all = []
+ for prior in priors:
+ res = chain.inference_results.filter(log_likelihood=prior)
+ p_vals = res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ self.assertEqual(len(p_vals), 11)
+ p_vals_all.append(p_vals)
+ iterations = res.order_by('iteration').values_list(
+ 'iteration', flat=True
+ )
+ expected = list(range(11))
+ self.assertTrue(np.array_equal(iterations, expected))
+
+ # transpose list of lists
+ p_vals_all = list(map(list, zip(*p_vals_all)))
+ fn = self.inference_mixin._pints_log_posterior
+ for idx, params in enumerate(p_vals_all):
+ print(f'comparing {fn(fn.to_search(params))} to {f_vals[idx]}')
+ self.assertTrue(
+ abs(fn(fn.to_search(params)) - f_vals[idx]) < 0.01
+ )
+
+ output_res = chain.inference_output_results.all()
+ self.assertTrue(len(output_res), 28)
+
+ inference = self.inference_mixin.inference
+ self.assertTrue(inference.time_elapsed > 0)
+ self.assertTrue(inference.number_of_function_evals > 0)
+
+
+class TestInferenceMixinSingleOutput(TestCase):
+ def setUp(self):
+ # ensure we've got nothing in the cache
+ cache._cache.flush_all()
+
+ self.inference, log_likelihood, _, _, _, _ = create_pd_inference()
+
+ # set uniform prior on everything, except amounts
+ for param in log_likelihood.parameters.all():
+ param.set_uniform_prior(0.0, 2.0)
+
+ # 'run' inference to create copies of models
+ self.inference.run_inference(test=True)
+
+ # create mixin object
+ self.inference_mixin = InferenceMixin(self.inference)
+
+ def test_inference_runs(self):
+ # tests that inference runs and writes results to db
+ self.inference_mixin.run_inference()
+
+ chains = self.inference_mixin.inference.chains.all()
+ self.assertEqual(len(chains), 3)
+ priors = self.inference_mixin._priors
+ for chain in chains:
+ fun_res = chain.inference_function_results
+ f_vals = fun_res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ self.assertEqual(len(f_vals), 11)
+ p_vals_all = []
+ for prior in priors:
+ res = chain.inference_results.filter(log_likelihood=prior)
+ p_vals = res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ self.assertEqual(len(p_vals), 11)
+ p_vals_all.append(p_vals)
+ iterations = res.order_by('iteration').values_list(
+ 'iteration', flat=True
+ )
+ expected = list(range(11))
+ self.assertTrue(np.array_equal(iterations, expected))
+
+ # don't test for inference log_posterior(param) = fn since they won't
+ # because of the way the 'best' params are picked
+
+ inference = self.inference_mixin.inference
+ self.assertTrue(inference.time_elapsed > 0)
+ self.assertTrue(inference.number_of_function_evals > 0)
+
+ def test_inference_can_be_restarted(self):
+ self.inference.chains.all().delete()
+ self.inference.chains.set([
+ InferenceChain.objects.create(inference=self.inference)
+ for i in range(self.inference.number_of_chains)
+ ])
+ self.inference.refresh_from_db()
+ for chain in self.inference.chains.all():
+ chain.inference_function_results.add(
+ InferenceFunctionResult.objects.create(
+ chain=chain,
+ iteration=0,
+ value=1.4
+ ),
+ InferenceFunctionResult.objects.create(
+ chain=chain,
+ iteration=1,
+ value=2.4
+ )
+ )
+ for prior in self.inference_mixin._priors:
+ chain.inference_results.add(
+ InferenceResult.objects.create(
+ chain=chain,
+ log_likelihood=prior,
+ iteration=0,
+ value=0.5,
+ ),
+ InferenceResult.objects.create(
+ chain=chain,
+ log_likelihood=prior,
+ iteration=1,
+ value=0.4,
+ )
+ )
+ chain.refresh_from_db()
+ self.inference.number_of_iterations = 1
+ self.inference.save()
+
+ # tests that inference runs and writes results to db
+ inference_mixin = InferenceMixin(self.inference)
+ inference_mixin.run_inference()
+
+ chains = inference_mixin.inference.chains.all()
+ self.assertEqual(len(chains), 3)
+ for chain in chains:
+ priors = inference_mixin._priors
+ fun_res = chain.inference_function_results
+ f_vals = fun_res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ self.assertEqual(len(f_vals), 11)
+ p_vals_all = []
+ for prior in priors:
+ res = chain.inference_results.filter(log_likelihood=prior)
+ p_vals = res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ self.assertEqual(len(p_vals), 11)
+ p_vals_all.append(p_vals)
+ iterations = res.order_by('iteration').values_list(
+ 'iteration', flat=True
+ )
+ expected = list(range(11))
+ self.assertTrue(np.array_equal(iterations, expected))
+
+
+class TestInferenceMixinSingleOutputOptimisationPopulation(TestCase):
+ def setUp(self):
+ # ensure we've got nothing in the cache
+ cache._cache.flush_all()
+
+ self.inference, log_likelihood, biomarker_type, \
+ _, _, _ = create_pd_inference()
+
+ # set uniform prior on everything, except
+ # we'll do a population prior on the first one
+ for i, param in enumerate(log_likelihood.parameters.all()):
+ if i == 0:
+ param.set_uniform_prior(
+ 0.0, 2.0, biomarker_type=biomarker_type
+ )
+ else:
+ param.set_uniform_prior(0.0, 2.0)
+
+ # 'run' inference to create copies of models
+ self.inference.run_inference(test=True)
+
+ # create mixin object
+ self.inference_mixin = InferenceMixin(self.inference)
+
+ def test_inference_runs(self):
+ # tests that inference runs and writes results to db
+ self.inference_mixin.run_inference()
+
+ chains = self.inference_mixin.inference.chains.all()
+ self.assertEqual(len(chains), 3)
+ priors = self.inference_mixin._priors
+ for chain in chains:
+ fun_res = chain.inference_function_results
+ f_vals = fun_res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ self.assertEqual(len(f_vals), 11)
+ for prior in priors:
+ res = chain.inference_results.filter(log_likelihood=prior)
+ p_vals = res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ length = prior.get_total_length()
+ self.assertEqual(len(p_vals), 11 * length)
+
+ # don't test for inference log_posterior(param) = fn since they won't
+ # because of the way the 'best' params are picked
+
+ inference = self.inference_mixin.inference
+ self.assertTrue(inference.time_elapsed > 0)
+ self.assertTrue(inference.number_of_function_evals > 0)
+
+
+class TestInferenceMixinSingleOutputOptimisationCovariate(TestCase):
+ def setUp(self):
+ # ensure we've got nothing in the cache
+ cache._cache.flush_all()
+
+ self.inference, log_likelihood, biomarker_type, \
+ covariate_biomarker_type, _, _ = create_pd_inference()
+
+ # set uniform prior on everything, except
+ # we'll do a population prior on the first one
+ for i, param in enumerate(log_likelihood.parameters.all()):
+ if i == 0:
+ # first param is sampled from a normal distribution with a mean
+ # derived from subject body weight
+ param.child.biomarker_type = covariate_biomarker_type
+ param.child.time_independent_data = True
+ param.child.form = LogLikelihood.Form.NORMAL
+ param.child.save()
+ body_weight_values, _, subjects = param.child.get_data()
+ param.length = len(subjects)
+ param.save()
+
+ # use a covariate to adjust the mean of the normal according to
+ # body weight
+ mean, sigma = param.child.get_noise_log_likelihoods()
+ mean.form = LogLikelihood.Form.EQUATION
+ mean.description = '1.0 if arg0 < 20 else 2.0'
+
+ mean.biomarker_type = covariate_biomarker_type
+ mean.time_independent_data = True
+ mean.save()
+ body_weight = LogLikelihood.objects.create(
+ name='Body weight',
+ inference=self.inference,
+ form=LogLikelihood.Form.FIXED,
+ biomarker_type=covariate_biomarker_type,
+ time_independent_data=True,
+ )
+ LogLikelihoodParameter.objects.create(
+ name='Body weight',
+ parent=mean,
+ child=body_weight,
+ parent_index=0,
+ length=len(subjects)
+ )
+ sigma.value = 0.01
+ sigma.save()
+ else:
+ param.set_uniform_prior(0.0, 2.0)
+
+ # 'run' inference to create copies of models
+ self.inference.run_inference(test=True)
+
+ # create mixin object
+ self.inference_mixin = InferenceMixin(self.inference)
+
+ def test_inference_runs(self):
+ # tests that inference runs and writes results to db
+ self.inference_mixin.run_inference()
+
+ chains = self.inference_mixin.inference.chains.all()
+ self.assertEqual(len(chains), 3)
+ priors = self.inference_mixin._priors
+ for chain in chains:
+ fun_res = chain.inference_function_results
+ f_vals = fun_res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ self.assertEqual(len(f_vals), 11)
+ for prior in priors:
+ res = chain.inference_results.filter(log_likelihood=prior)
+ p_vals = res.order_by('iteration').values_list(
+ 'value', flat=True
+ )
+ length = prior.get_total_length()
+ self.assertEqual(len(p_vals), 11 * length)
+
+ # don't test for inference log_posterior(param) = fn since they won't
+ # because of the way the 'best' params are picked
+
+ inference = self.inference_mixin.inference
+ self.assertTrue(inference.time_elapsed > 0)
+ self.assertTrue(inference.number_of_function_evals > 0)
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_loglikelihood.py b/pkpdapp/pkpdapp/tests/test_models/test_loglikelihood.py
new file mode 100644
index 00000000..db0e4992
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_loglikelihood.py
@@ -0,0 +1,100 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.test import TestCase
+from pkpdapp.models import (
+ LogLikelihood,
+ LogLikelihoodParameter,
+)
+from pkpdapp.tests import create_pd_inference
+
+
+class TestInferenceMixinPdModel(TestCase):
+ def setUp(self):
+ self.inference, self.log_likelihood, self.biomarker_type, \
+ self.covariate_biomarker_type, self.model, \
+ _ = create_pd_inference(
+ sampling=True)
+
+ def test_create_pymc3_model(self):
+
+ # add a prior on the first param
+ first_param = self.log_likelihood.parameters.first()
+ prior_name = first_param.child.name
+ first_param.child.form = LogLikelihood.Form.NORMAL
+ first_param.child.save()
+
+ output = self.log_likelihood.parents.first()
+ model = output.create_pymc3_model()
+
+ # check everything is in there
+ model[prior_name]
+ model[output.name]
+ model.logp({prior_name: 0.3})
+
+ # check we can run predictive posteriors
+ model.fastfn([
+ model[self.log_likelihood.name + output.name]
+ ])
+
+ def test_population_model_with_covariate(self):
+ output = self.log_likelihood.parents.first()
+
+ values, times, subjects = output.get_data()
+ n_subjects = len(set(subjects))
+ print('n_subjects', n_subjects)
+
+ # first param is sampled from a normal distribution with a mean
+ # derived from subject body weight
+ first_param = self.log_likelihood.parameters.first()
+ first_param.length = n_subjects
+ first_param.save()
+ first_param.child.biomarker_type = self.covariate_biomarker_type
+ first_param.child.time_independent_data = True
+ first_param.child.form = LogLikelihood.Form.NORMAL
+ first_param.child.save()
+
+ # use a covariate to adjust the mean of the normal according to body
+ # weight
+ mean, sigma = first_param.child.get_noise_log_likelihoods()
+ mean.form = LogLikelihood.Form.EQUATION
+ mean.description = '1.0 if arg0 < 20 else 2.0'
+
+ mean.biomarker_type = self.covariate_biomarker_type
+ mean.time_independent_data = True
+ mean.save()
+ body_weight = LogLikelihood.objects.create(
+ name='Body weight',
+ inference=self.inference,
+ form=LogLikelihood.Form.FIXED,
+ biomarker_type=self.covariate_biomarker_type,
+ time_independent_data=True,
+ )
+ body_weight_values, _, subjects = body_weight.get_data()
+ LogLikelihoodParameter.objects.create(
+ name='Body weight',
+ parent=mean,
+ child=body_weight,
+ parent_index=0,
+ length=len(subjects)
+ )
+ sigma.value = 0.01
+ sigma.save()
+
+ model = output.create_pymc3_model()
+
+ model.logp({first_param.child.name: [0.3] * n_subjects})
+
+ max_logp = model[first_param.child.name].logp({
+ first_param.child.name: [
+ 1.0 if value < 20 else 2.0
+ for value in body_weight_values
+ ]
+ })
+ lower_logp = model[first_param.child.name].logp({
+ first_param.child.name: [1.0] * n_subjects
+ })
+ self.assertLess(lower_logp, max_logp)
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_mechanistic_model.py b/pkpdapp/pkpdapp/tests/test_models/test_mechanistic_model.py
new file mode 100644
index 00000000..38e93670
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_mechanistic_model.py
@@ -0,0 +1,136 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from django.test import TestCase
+from pkpdapp.models import (
+ PharmacodynamicModel,
+ Protocol,
+ PharmacokineticModel,
+ CombinedModel,
+ Dose,
+ Unit,
+)
+import myokit
+from django.core.exceptions import ValidationError
+from django.core.cache import cache
+import numpy as np
+
+
+class TestPharmodynamicModel(TestCase):
+ def setUp(self):
+ cache.clear()
+
+ def test_model_bad_mmt(self):
+ with self.assertRaises(myokit.ParseError):
+ PharmacodynamicModel.objects.create(
+ name="my_cool_model",
+ description="description for my cool model",
+ mmt="this is not sbml",
+ )
+
+ def test_model_clean(self):
+ m = PharmacodynamicModel(
+ name="my_cool_model",
+ description="description for my cool model",
+ mmt="this is not xml",
+ )
+ with self.assertRaises(ValidationError):
+ m.clean()
+
+ def test_model_creation(self):
+ m = PharmacodynamicModel.objects.create(
+ name="my_cool_model",
+ description="description for my cool model",
+ )
+ self.assertTrue(isinstance(m, PharmacodynamicModel))
+
+ def test_myokit_model(self):
+ m = PharmacodynamicModel.objects.get(
+ name="tumour_growth_gompertz",
+ )
+ model = m.get_myokit_model()
+ model_variables = [v.name() for v in model.variables()]
+ test_model_variables = ["TS0", "TSmax", "beta", "Growth", "TS", "t"]
+ self.assertCountEqual(model_variables, test_model_variables)
+
+
+class TestDosedPharmokineticModel(TestCase):
+ def setUp(self):
+ cache.clear()
+ self.pk = PharmacokineticModel.objects.get(
+ name="one_compartment_clinical",
+ )
+
+ self.model = CombinedModel.objects.create(
+ pk_model=self.pk,
+ )
+
+ self.p = Protocol.objects.create(
+ amount_unit=Unit.objects.get(symbol="pmol"),
+ time_unit=Unit.objects.get(symbol="h"),
+ name="my_cool_protocol",
+ dose_type=Protocol.DoseType.INDIRECT,
+ )
+
+ v = self.model.variables.get(qname="PKCompartment.A1")
+ v.protocol = self.p
+ v.save()
+
+ def test_store_model(self):
+ stored_model = self.model.create_stored_model()
+ self.assertTrue(isinstance(stored_model, CombinedModel))
+ self.assertTrue(stored_model.read_only)
+ self.assertEqual(
+ len(stored_model.variables.all()), len(self.model.variables.all())
+ )
+ v = stored_model.variables.get(qname="PKCompartment.A1")
+ self.assertEqual(v.protocol.name, "my_cool_protocol")
+ self.assertNotEqual(v.protocol.id, self.p.id)
+
+ def test_reset_to_default(self):
+ v = self.model.variables.get(qname="PKCompartment.CL")
+ self.assertNotEqual(v.default_value, 8)
+ self.assertNotEqual(v.unit.symbol, "mL/h")
+
+ self.model.reset_params_to_defaults("H", "LM")
+
+ v = self.model.variables.get(qname="PKCompartment.CL")
+ self.assertEqual(v.default_value, 8)
+ self.assertEqual(v.unit.symbol, "mL/h")
+
+ def test_myokit_model(self):
+ model = self.model.get_myokit_model()
+ pk_model = self.pk.get_myokit_model()
+ model_variables = [v.name() for v in model.variables()]
+ pk_model_variables = [v.name() for v in pk_model.variables()]
+
+ # check that the absorption_rate and dose_rate variable has been added,
+ # and the extra drug_amount state variable
+ self.assertCountEqual(
+ model_variables,
+ pk_model_variables,
+ )
+
+ # run a simulation with a a dose events
+ Dose.objects.create(
+ protocol=self.p,
+ start_time=0,
+ duration=0.1,
+ amount=1000,
+ )
+
+ # dosed model should have a concentration at t ~ 0.5
+ # of greater than 0.01
+ sim = self.model.get_myokit_simulator()
+
+ output = sim.run(self.model.time_max)
+ index = np.where(np.array(output["environment.t"]) > 0.5)[0][0]
+ self.assertGreater(output["PKCompartment.C1"][index], 0.01)
+
+ # non-dosed model should have a concentration at t ~ 0.5 of near zero
+ pk_sim = self.pk.get_myokit_simulator()
+ output = pk_sim.run(self.pk.time_max)
+ index = np.where(np.array(output["environment.t"]) > 0.5)[0][0]
+ self.assertLess(output["PKCompartment.C1"][index], 1e-6)
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_myokit_forward_model.py b/pkpdapp/pkpdapp/tests/test_models/test_myokit_forward_model.py
new file mode 100644
index 00000000..0dbdd119
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_myokit_forward_model.py
@@ -0,0 +1,230 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+from django.test import TestCase
+from numpy.testing import assert_almost_equal
+from pkpdapp.models import (
+ PharmacodynamicModel,
+ MyokitForwardModel,
+ PharmacokineticModel
+)
+import numpy as np
+
+
+class TestMyokitForwardModelSingleOutput(TestCase):
+ def setUp(self):
+ m = PharmacodynamicModel.objects.get(
+ name='tumour_growth_gompertz',
+ )
+ self.model = m.get_myokit_model()
+ self.simulator = m.get_myokit_simulator()
+
+ self.parameter_dict = {
+ 'PDCompartment.beta': 1,
+ 'PDCompartment.TS0': 1,
+ 'PDCompartment.TSmax': 1,
+ }
+
+ all_keys = list(self.parameter_dict.keys())
+ self.fixed_dict = {
+ 'PDCompartment.TS0': 1,
+ }
+
+ variable_keys = (
+ [k for k in all_keys if k not in list(self.fixed_dict.keys())]
+ )
+ self.variable_parameter_values = [self.parameter_dict[v]
+ for v in variable_keys]
+
+ def test_run_myokit_pints_forward_model(self):
+ times = np.linspace(0, 100)
+
+ forward_model = MyokitForwardModel(
+ myokit_model=self.model,
+ myokit_simulator=self.simulator,
+ outputs=["PDCompartment.TS"],
+ times=[times],
+ fixed_parameter_dict=self.fixed_dict,
+ conversion_factors=[1.0],
+ )
+
+ z = forward_model.simulate(self.variable_parameter_values)
+ self.assertEqual(len(z), 1)
+ self.assertEqual(len(z[0]), len(times))
+
+ # try without any fixed parameters
+ forward_model = MyokitForwardModel(
+ myokit_model=self.model,
+ myokit_simulator=self.simulator,
+ outputs=["PDCompartment.TS"],
+ times=[times],
+ conversion_factors=[1.0],
+ )
+ z1 = forward_model.simulate(list(self.parameter_dict.values()))
+ self.assertTrue(np.array_equal(z, z1))
+
+ # try model with different variable parameters and check output differs
+ new_fixed_dict = {
+ 'PDCompartment.TS0': 2,
+ }
+ forward_model = MyokitForwardModel(
+ myokit_model=self.model,
+ myokit_simulator=self.simulator,
+ outputs=["PDCompartment.TS"],
+ times=[times],
+ fixed_parameter_dict=new_fixed_dict,
+ conversion_factors=[1.0],
+ )
+ z3 = forward_model.simulate(self.variable_parameter_values)
+ self.assertTrue(not np.array_equal(z3, z))
+
+ # check model with different parameter inputs gives different result
+ self.variable_parameter_values[0] = 7
+ forward_model = MyokitForwardModel(
+ myokit_model=self.model,
+ myokit_simulator=self.simulator,
+ outputs=["PDCompartment.TS"],
+ times=[times],
+ fixed_parameter_dict=new_fixed_dict,
+ conversion_factors=[1.0],
+ )
+ z4 = forward_model.simulate(self.variable_parameter_values)
+ self.assertTrue(not np.array_equal(z4, z3))
+
+ # try with subjects now, should get same result
+ times = np.linspace(0, 100)
+ n_subjects = 7
+ subjects = list(range(n_subjects)) * (len(times) // n_subjects + 1)
+ subjects = subjects[:len(times)]
+ all_keys = list(self.parameter_dict.keys())
+
+ fixed_dict = {
+ 'PDCompartment.TS0': [1] * n_subjects,
+ }
+
+ variable_keys = (
+ [k for k in all_keys if k not in list(self.fixed_dict.keys())]
+ )
+ variable_parameter_values = [
+ [self.parameter_dict[v]] * n_subjects for v in variable_keys
+ ]
+ variable_parameter_values = np.array(variable_parameter_values)
+ print('variable_parameter_values', variable_parameter_values.shape)
+
+ forward_model = MyokitForwardModel(
+ myokit_model=self.model,
+ myokit_simulator=self.simulator,
+ outputs=["PDCompartment.TS"],
+ times=[times],
+ subjects=[subjects],
+ fixed_parameter_dict=fixed_dict,
+ conversion_factors=[1.0],
+ )
+
+ z_subjects = forward_model.simulate(variable_parameter_values)
+ self.assertEqual(len(z_subjects), 1)
+ self.assertEqual(len(z_subjects[0]), len(times))
+ np.testing.assert_almost_equal(z_subjects[0], z[0])
+
+
+class TestMyokitPintsForwardModelMultipleOutput(TestCase):
+ def setUp(self):
+ m = PharmacokineticModel.objects.get(
+ name='three_compartment_preclinical',
+ )
+ self.model = m.get_myokit_model()
+ self.simulator = m.get_myokit_simulator()
+
+ def test_runs(self):
+ # all parameters are:
+ # full_dict = {
+ # 'PKCompartment.tlag': 1,
+ # 'PKCompartment.ka': 1,
+ # 'PKCompartment.F': 1,
+ # 'PKCompartment.V1': 1,
+ # 'PKCompartment.V2': 1,
+ # 'PKCompartment.V3': 1,
+ # 'PKCompartment.CL': 1,
+ # 'PKCompartment.Q1': 1,
+ # 'PKCompartment.Q2': 1,
+ # 'PKCompartment.CLmax': 1,
+ # 'PKCompartment.Km': 1,
+ # 'PKCompartment.ke0': 1,
+ # 'PKCompartment.Kpu': 1,
+ # }
+ fixed_dict = {
+ 'PKCompartment.tlag': 1,
+ 'PKCompartment.CLmax': 1,
+ 'PKCompartment.ke0': 1,
+ }
+ variable_parameters = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+
+ desired_outputs = [
+ 'PKCompartment.A1',
+ 'PKCompartment.A2',
+ 'PKCompartment.A3',
+ ]
+
+ conversion_factors = [
+ 1.0,
+ 1.0,
+ 1.0,
+ ]
+
+ times = [
+ np.linspace(0, 100, 33),
+ np.linspace(0, 100, 10),
+ np.linspace(0, 100, 20),
+ ]
+
+ forward_model = MyokitForwardModel(
+ myokit_model=self.model,
+ myokit_simulator=self.simulator,
+ fixed_parameter_dict=fixed_dict,
+ outputs=desired_outputs,
+ times=times,
+ conversion_factors=conversion_factors
+ )
+
+ z = forward_model.simulate(variable_parameters)
+ self.assertEqual(len(z), 3)
+ self.assertEqual(len(z[0]), 33)
+ self.assertEqual(len(z[1]), 10)
+ self.assertEqual(len(z[2]), 20)
+
+ # do another ordering
+ desired_outputs = [
+ 'PKCompartment.A3',
+ 'PKCompartment.A1',
+ 'PKCompartment.A2',
+ ]
+
+ conversion_factors = [
+ 1.0,
+ 1.0,
+ 1.0,
+ ]
+
+ times = [
+ np.linspace(0, 100, 20),
+ np.linspace(0, 100, 33),
+ np.linspace(0, 100, 10),
+ ]
+
+ forward_model = MyokitForwardModel(
+ myokit_model=self.model,
+ myokit_simulator=self.simulator,
+ outputs=desired_outputs,
+ times=times,
+ fixed_parameter_dict=fixed_dict,
+ conversion_factors=conversion_factors
+ )
+
+ z_new = forward_model.simulate(variable_parameters)
+ assert_almost_equal(z_new[0], z[2])
+ assert_almost_equal(z_new[1], z[0])
+ assert_almost_equal(z_new[2], z[1])
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_other.py b/pkpdapp/pkpdapp/tests/test_models/test_other.py
new file mode 100644
index 00000000..002dc179
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_other.py
@@ -0,0 +1,89 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import pkpdapp.tests # noqa: F401
+from django.test import TestCase
+from pkpdapp.models import (
+ Dataset, Project,
+ PharmacodynamicModel,
+ Compound,
+)
+from django.contrib.auth.models import User
+from django.utils import timezone
+
+
+class TestCompoundModel(TestCase):
+ def test_model_creation(self):
+ c = Compound.objects.create(
+ name='my_cool_compound',
+ description='placebo',
+ molecular_mass=100,
+ target_molecular_mass=100,
+ )
+ self.assertTrue(isinstance(c, Compound))
+
+
+class TestProfileModel(TestCase):
+ def test_profile_creation(self):
+ u = User.objects.create_user(
+ 'john', 'lennon@thebeatles.com', 'johnpassword'
+ )
+ c = Compound.objects.create(
+ name='my_cool_compound',
+ description='placebo',
+ molecular_mass=100,
+ target_molecular_mass=100,
+ )
+ p = Project.objects.create(
+ name='my_cool_project',
+ description='description for my cool project',
+ compound=c,
+ )
+ self.assertEqual(u.profile.user.username, 'john')
+ u.profile.selected_project = p
+ self.assertEqual(u.profile.selected_project, p)
+
+
+class TestProjectModel(TestCase):
+ def setUp(self):
+ c = Compound.objects.create(
+ name='my_cool_compound',
+ description='placebo',
+ molecular_mass=100,
+ target_molecular_mass=100,
+ )
+
+ Project.objects.create(
+ name='my_cool_project',
+ description='description for my cool project',
+ compound=c,
+ )
+
+ def test_project_creation(self):
+ p = Project.objects.get(name='my_cool_project')
+ self.assertTrue(isinstance(p, Project))
+
+ def test_add_to_project(self):
+ p = Project.objects.get(name='my_cool_project')
+ d = Dataset.objects.create(
+ name='my_cool_dataset',
+ datetime=timezone.now(),
+ description='description for my cool dataset',
+ )
+ p.datasets.add(d)
+ self.assertQuerysetEqual(p.datasets.all(), [repr(d)])
+
+ m = PharmacodynamicModel.objects.create(
+ name='my_cool_model',
+ description='description for my cool model',
+ )
+ p.pd_models.add(m)
+ self.assertQuerysetEqual(p.pd_models.all(), [repr(m)])
+
+ u = User.objects.create_user(
+ 'john', 'lennon@thebeatles.com', 'johnpassword'
+ )
+ p.users.add(u)
+ self.assertQuerysetEqual(p.users.all(), [repr(u)])
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_pkpd_model.py b/pkpdapp/pkpdapp/tests/test_models/test_pkpd_model.py
new file mode 100644
index 00000000..fa49f197
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_pkpd_model.py
@@ -0,0 +1,146 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+
+from django.contrib.auth.models import User
+from django.test import TestCase
+from rest_framework.test import APIClient
+
+from pkpdapp.models import (
+ CombinedModel,
+ PharmacodynamicModel,
+ PharmacokineticModel,
+ PkpdMapping,
+ Project,
+ DerivedVariable,
+)
+
+
+class TestPkpdModel(TestCase):
+ def setUp(self):
+ self.project = Project.objects.get(
+ name="demo",
+ )
+
+ user = User.objects.get(username="demo")
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_combined_model_creation(self):
+ pk_model = PharmacokineticModel.objects.get(name="one_compartment_clinical")
+ pd_model = PharmacodynamicModel.objects.get(
+ name="indirect_effects_stimulation_production"
+ )
+ pkpd_model = CombinedModel.objects.create(
+ name="my wonderful model",
+ pk_model=pk_model,
+ pd_model=pd_model,
+ project=self.project,
+ )
+ PkpdMapping.objects.create(
+ pkpd_model=pkpd_model,
+ pk_variable=pkpd_model.variables.get(
+ qname="PKCompartment.C1",
+ ),
+ pd_variable=pkpd_model.variables.get(
+ qname="PDCompartment.C_Drug",
+ ),
+ )
+ vars = pkpd_model.variables.values_list("qname", flat=True)
+ for var in ["PKCompartment.C1", "PDCompartment.C_Drug", "PDCompartment.E"]:
+ self.assertIn(var, vars)
+ self.assertFalse(
+ pkpd_model.get_myokit_model().get("PKCompartment.C1").is_state()
+ )
+ self.assertFalse(
+ pkpd_model.get_myokit_model().get("PKCompartment.C1").is_constant()
+ )
+ self.assertTrue(pkpd_model.get_myokit_model().get("PDCompartment.E").is_state())
+ self.assertFalse(pkpd_model.variables.get(qname="PKCompartment.C1").state)
+ self.assertFalse(pkpd_model.variables.get(qname="PKCompartment.C1").constant)
+ self.assertTrue(pkpd_model.variables.get(qname="PDCompartment.E").state)
+ pkpd_model.get_myokit_model().validate()
+ self.assertFalse(
+ pkpd_model.variables.get(qname="PDCompartment.C_Drug").constant
+ )
+
+ def test_combined_model_with_derived_variable(self):
+ pk_model = PharmacokineticModel.objects.get(name="one_compartment_clinical")
+ pd_model = PharmacodynamicModel.objects.get(
+ name="indirect_effects_stimulation_production"
+ )
+ pkpd_model = CombinedModel.objects.create(
+ name="my wonderful model",
+ pk_model=pk_model,
+ pd_model=pd_model,
+ project=self.project,
+ )
+ DerivedVariable.objects.create(
+ pkpd_model=pkpd_model,
+ pk_variable=pkpd_model.variables.get(
+ qname="PKCompartment.C1",
+ ),
+ type=DerivedVariable.Type.FRACTION_UNBOUND_PLASMA,
+ )
+ derived_var_qname = "PKCompartment.calc_C1_f"
+ PkpdMapping.objects.create(
+ pkpd_model=pkpd_model,
+ pk_variable=pkpd_model.variables.get(
+ qname=derived_var_qname,
+ ),
+ pd_variable=pkpd_model.variables.get(
+ qname="PDCompartment.C_Drug",
+ ),
+ )
+ vars = pkpd_model.variables.values_list("qname", flat=True)
+ for var in [derived_var_qname, "PDCompartment.C_Drug", "PDCompartment.E"]:
+ self.assertIn(var, vars)
+ self.assertFalse(
+ pkpd_model.get_myokit_model().get(derived_var_qname).is_state()
+ )
+ self.assertFalse(
+ pkpd_model.get_myokit_model().get(derived_var_qname).is_constant()
+ )
+ self.assertFalse(
+ pkpd_model.get_myokit_model().get("PDCompartment.C_Drug").is_constant()
+ )
+
+ def test_combine_multiple_pd_models(self):
+ pk = PharmacokineticModel.objects.get(
+ name="one_compartment_preclinical",
+ )
+ pd = PharmacodynamicModel.objects.get(
+ name="tumour_growth_gompertz",
+ )
+ pd2 = PharmacodynamicModel.objects.get(
+ name="tumour_growth_inhibition_delay_cell_distribution_conc_prop_kill", # noqa E501
+ )
+ combined = CombinedModel.objects.create(
+ name="my_combined_model",
+ pk_model=pk,
+ pd_model=pd,
+ pd_model2=pd2,
+ )
+
+ pk_vars = [v.qname() for v in pk.get_myokit_model().variables()]
+ pd_vars = [
+ v.qname()
+ for v in pd.get_myokit_model().variables()
+ if v.qname() != "environment.t"
+ ]
+ pd2_vars = [
+ v.qname().replace("PDCompartment", "PDCompartment2")
+ for v in pd2.get_myokit_model().variables()
+ if v.qname() != "environment.t"
+ ]
+ expected_vars = [v for v in pk_vars + pd_vars + pd2_vars]
+ removed_vars = ["PDCompartment2.TS", "PDCompartment2.TS0"]
+ for var in removed_vars:
+ expected_vars.remove(var)
+ model = combined.get_myokit_model()
+ model_vars = [v.qname() for v in model.variables()]
+ self.assertCountEqual(model_vars, expected_vars)
+ print("combined model validated", model.code())
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_protocol.py b/pkpdapp/pkpdapp/tests/test_models/test_protocol.py
new file mode 100644
index 00000000..ef6b05dd
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_protocol.py
@@ -0,0 +1,36 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+from django.test import TestCase
+from pkpdapp.models import (
+ Protocol,
+ Compound,
+ Unit,
+)
+
+
+class TestProtocolModel(TestCase):
+ def test_model_creation(self):
+ au = Unit.objects.get(symbol='mg')
+ tu = Unit.objects.get(symbol='h')
+
+ c = Compound.objects.create(
+ name='my_cool_compound',
+ description='placebo',
+ molecular_mass=100,
+ target_molecular_mass=100,
+ )
+
+ # test optional dataset
+ p = Protocol.objects.create(
+ name='my_cool_protocol',
+ compound=c,
+ amount_unit=au,
+ time_unit=tu,
+ )
+
+ self.assertTrue(isinstance(p, Protocol))
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_subject.py b/pkpdapp/pkpdapp/tests/test_models/test_subject.py
new file mode 100644
index 00000000..a720089f
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_subject.py
@@ -0,0 +1,57 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+from django.test import TestCase
+from pkpdapp.models import (
+ Dataset,
+ Subject,
+)
+from django.utils import timezone
+from django.db.utils import IntegrityError
+
+
+class TestSubjectModel(TestCase):
+ def setUp(self):
+ self.dataset = Dataset.objects.create(
+ name='test_subject_model',
+ datetime=timezone.now(),
+ description='description for my cool dataset',
+ )
+
+ def test_subject_creation(self):
+ metadata = {
+ 'test': 2
+ }
+ s = Subject.objects.create(
+ id_in_dataset=1, dataset=self.dataset, metadata=metadata
+ )
+ self.assertTrue(isinstance(s, Subject))
+
+ def test_subject_unique_constraint(self):
+
+ metadata = {
+ 'test': 2
+ }
+ Subject.objects.create(
+ id_in_dataset=2, dataset=self.dataset, metadata=metadata
+ )
+
+ # this is ok
+ d2 = Dataset.objects.create(
+ name='test_subject_model2',
+ datetime=timezone.now(),
+ description='description for my cool dataset',
+ )
+ Subject.objects.create(
+ id_in_dataset=2, dataset=d2, metadata=metadata
+ )
+
+ # this should raise error
+ with self.assertRaises(IntegrityError):
+ Subject.objects.create(
+ id_in_dataset=2, dataset=self.dataset, metadata=metadata
+ )
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_unit.py b/pkpdapp/pkpdapp/tests/test_models/test_unit.py
new file mode 100644
index 00000000..43c61859
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_unit.py
@@ -0,0 +1,77 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+from django.test import TestCase
+from pkpdapp.models import (
+ Unit, Compound
+)
+
+
+class TestUnitModel(TestCase):
+ def setUp(self):
+ self.compound = Compound.objects.create(
+ name='test_unit_model',
+ description='description for my cool compound',
+ )
+
+ def check_compatible_unit(
+ self, unit_symbol, compatible_units, compound=None
+ ):
+ unit = Unit.objects.get(symbol=unit_symbol)
+ compat_symbols = [
+ u.symbol for u in unit.get_compatible_units(compound=compound)]
+ self.assertCountEqual(compat_symbols, compatible_units)
+
+ def test_compatible_units(self):
+ self.check_compatible_unit('s', ['s', 'min', 'h', 'day', 'week'])
+ self.check_compatible_unit(
+ 'ng/mL', ['ng/mL', 'µg/mL', 'mg/L', 'ng/L', 'g/L', 'g/dL', 'pg/mL'
+ ])
+
+ def test_compatible_units_mols(self):
+ self.check_compatible_unit('nmol', ['mol', 'nmol', 'pmol', 'µmol'])
+ self.check_compatible_unit(
+ 'nmol',
+ [
+ 'mol', 'nmol', 'pmol', 'µmol', 'mg', 'g', 'ng', 'kg'
+ ],
+ compound=self.compound
+ )
+ self.check_compatible_unit('mg', ['mg', 'g', 'ng', 'kg'])
+ self.check_compatible_unit(
+ 'mg',
+ ['mol', 'nmol', 'pmol', 'µmol', 'mg', 'g', 'ng', 'kg'],
+ compound=self.compound
+ )
+ self.check_compatible_unit(
+ 'nmol/L',
+ [
+ 'nmol/L', 'pmol/L', 'µmol/L', 'mg/L',
+ 'g/L', 'ng/mL', 'ng/L', 'pg/mL', 'µg/mL', 'g/dL'
+ ],
+ compound=self.compound
+ )
+
+ def test_compatible_units_mols_per_kg(self):
+ self.check_compatible_unit(
+ 'nmol/kg', ['nmol/kg', 'pmol/kg', 'µmol/kg'])
+ self.check_compatible_unit(
+ 'nmol/kg',
+ ['nmol/kg', 'pmol/kg', 'µmol/kg', 'mg/kg',
+ 'pg/kg', 'µg/kg', 'ng/kg', ''],
+ compound=self.compound
+ )
+ self.check_compatible_unit(
+ 'mg/kg', ['mg/kg', 'pg/kg', 'µg/kg', 'ng/kg', ''])
+ self.check_compatible_unit(
+ 'mg/kg',
+ [
+ 'nmol/kg', 'pmol/kg', 'µmol/kg', 'mg/kg',
+ 'pg/kg', 'µg/kg', 'ng/kg', 'g/mol', 'g/nmol', ''
+ ],
+ compound=self.compound
+ )
diff --git a/pkpdapp/pkpdapp/tests/test_models/test_variable.py b/pkpdapp/pkpdapp/tests/test_models/test_variable.py
new file mode 100644
index 00000000..1faad709
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_models/test_variable.py
@@ -0,0 +1,55 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import pkpdapp.tests # noqa: F401
+from django.db.utils import IntegrityError
+from pkpdapp.models import (
+ Variable, Unit,
+ PharmacokineticModel,
+)
+
+
+def TestVariableModel(TestCase):
+ def test_variable_creation(self):
+ n = 'variable name'
+ u = Unit.objects.get(symbol='mg')
+ lb = 0.001
+ ub = 3.1415
+ s = 'LN'
+ ls = 'LG'
+ pk = PharmacokineticModel.objects\
+ .get(name='one_compartment_pk_model')
+
+ v = Variable.objects.create(
+ name=n,
+ unit=u,
+ scale=s,
+ pk_model=pk,
+ lower_bound=lb,
+ upper_bound=ub
+ )
+ self.assertTrue(isinstance(v, Variable))
+
+ with self.assertRaises(IntegrityError) as context:
+ Variable.objects.create(
+ name=n,
+ unit=u,
+ scale=s,
+ lower_bound=lb,
+ upper_bound=ub
+ )
+ err_msg = 'variable must belong to a model'
+ self.assertTrue(err_msg in str(context.exception))
+
+ with self.assertRaises(IntegrityError) as context:
+ Variable.objects.create(
+ name=n,
+ unit=u,
+ scale=ls,
+ lower_bound=0,
+ upper_bound=ub
+ )
+ err_msg = 'log scale must have a lower bound greater than zero'
+ self.assertTrue(err_msg in str(context.exception))
diff --git a/pkpdapp/pkpdapp/tests/test_serializers/__init__.py b/pkpdapp/pkpdapp/tests/test_serializers/__init__.py
new file mode 100644
index 00000000..d0505307
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_serializers/__init__.py
@@ -0,0 +1,5 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
diff --git a/pkpdapp/pkpdapp/tests/test_serializers/test_inference.py b/pkpdapp/pkpdapp/tests/test_serializers/test_inference.py
new file mode 100644
index 00000000..4ea4f5a2
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_serializers/test_inference.py
@@ -0,0 +1,100 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from django.test import TestCase
+from rest_framework.exceptions import ValidationError
+from pkpdapp.models import (
+ InferenceMixin
+)
+from pkpdapp.api.serializers import (
+ InferenceSerializer, InferenceChainSerializer,
+)
+from pkpdapp.tests import create_pd_inference
+
+
+class TestInferenceSerializer(TestCase):
+ def setUp(self):
+ self.inference, log_likelihood, biomarker_type, \
+ _, self.model, _ = create_pd_inference(
+ sampling=False)
+
+ # set uniform prior on everything, except amounts
+ for i, param in enumerate(
+ log_likelihood.parameters.all()
+ ):
+ if i == 0:
+ param.set_uniform_prior(
+ 0.0, 2.0, biomarker_type=biomarker_type
+ )
+ else:
+ param.set_uniform_prior(0.0, 2.0)
+
+ def test_create(self):
+ serializer = InferenceSerializer()
+ data = {
+ 'name': 'test',
+ 'log_likelihoods': [],
+ 'project': self.inference.project.id,
+ }
+ validated_data = serializer.to_internal_value(data)
+ new_inference = serializer.create(validated_data)
+ self.assertEqual(new_inference.name, 'test')
+ self.assertEqual(len(new_inference.log_likelihoods.all()), 0)
+
+ def test_update(self):
+ serializer = InferenceSerializer(
+ self.inference
+ )
+ data = serializer.data
+ old_number_of_loglikelihoods = len(data['log_likelihoods'])
+ data['name'] = 'fred'
+ data['log_likelihoods'].append({
+ 'name': 'x',
+ 'form': 'N',
+ 'parameters': [],
+ })
+ validated_data = serializer.to_internal_value(data)
+ serializer.update(self.inference, validated_data)
+ self.assertEqual(self.inference.name, 'fred')
+
+ # new prior will add three new log_likelihood
+ # since a normal has 2 params
+ self.assertEqual(
+ len(self.inference.log_likelihoods.all()),
+ old_number_of_loglikelihoods + 3
+ )
+
+ # do it again with the same name, should have validation error
+ serializer = InferenceSerializer(
+ self.inference
+ )
+ data = serializer.data
+ old_number_of_loglikelihoods = len(data['log_likelihoods'])
+ data['log_likelihoods'].append({
+ 'name': 'x',
+ 'form': 'N',
+ 'parameters': [],
+ })
+ with self.assertRaisesRegex(
+ ValidationError,
+ "all log_likelihoods in an inference must have unique names"
+ ):
+ validated_data = serializer.to_internal_value(data)
+
+ def test_inference_results(self):
+ # create mixin object
+ inference_mixin = InferenceMixin(self.inference)
+ inference_mixin.run_inference()
+
+ chain = self.inference.chains.first()
+ chain_serializer = InferenceChainSerializer(chain)
+ data = chain_serializer.data
+ self.assertTrue('outputs' in data)
+ self.assertTrue(len(data['outputs']) > 0)
+ self.assertTrue('data' in data)
+ self.assertTrue('kde' in data['data'])
+ self.assertTrue(len(data['data']['kde']) > 0)
+ self.assertTrue('chain' in data['data'])
+ self.assertTrue(len(data['data']['chain']) > 0)
diff --git a/pkpdapp/pkpdapp/tests/test_serializers/test_likelihoods.py b/pkpdapp/pkpdapp/tests/test_serializers/test_likelihoods.py
new file mode 100644
index 00000000..1672c583
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_serializers/test_likelihoods.py
@@ -0,0 +1,37 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from django.test import TestCase
+from pkpdapp.api.serializers import (
+ LogLikelihoodSerializer
+)
+from pkpdapp.tests import create_pd_inference
+
+
+class TestLoglikelihoodSerializer(TestCase):
+ def setUp(self):
+ self.inference, self.log_likelihood, self.biomarker_type, \
+ _, self.model, _ = create_pd_inference()
+ self.parameters = self.log_likelihood.parameters.all()
+ self.prior = self.parameters[0].child
+
+ def test_serialize(self):
+ serializer = LogLikelihoodSerializer(
+ self.inference.log_likelihoods.all(),
+ many=True
+ )
+ data = serializer.data
+ self.assertEqual(len(data), 6)
+
+ def test_update(self):
+ serializer = LogLikelihoodSerializer(self.prior)
+ data = serializer.data
+
+ # update fixed value of 1st param
+ data['form'] = 'N'
+
+ validated_data = serializer.to_internal_value(data)
+ serializer.update(self.prior, validated_data)
+ self.assertEqual(self.prior.parameters.count(), 2)
diff --git a/pkpdapp/pkpdapp/tests/test_serializers/test_models.py b/pkpdapp/pkpdapp/tests/test_serializers/test_models.py
new file mode 100644
index 00000000..fcadd116
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_serializers/test_models.py
@@ -0,0 +1,66 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import pkpdapp.tests # noqa: F401
+import codecs
+from django.test import TestCase
+import urllib.request
+from pkpdapp.models import (
+ PharmacodynamicModel,
+ Project,
+)
+from pkpdapp.api.serializers import (
+ PharmacodynamicSbmlSerializer, PharmacodynamicSerializer
+)
+
+BASE_URL_DATASETS = 'https://raw.githubusercontent.com/pkpdapp-team/pkpdapp-datafiles/main/' # noqa: E501
+
+
+class TestPdModelSerializer(TestCase):
+ def setUp(self):
+ self.project = Project.objects.get(
+ name='demo',
+ )
+
+ def test_sbml_serialize(self):
+ pd_model = PharmacodynamicModel.objects.create(
+ name='test'
+ )
+ for filename in [
+ 'usecase2/ABx_updated3.xml'
+ ]:
+ with urllib.request.urlopen(
+ BASE_URL_DATASETS + filename, timeout=5
+ ) as f:
+ sbml_str = codecs.decode(f.read(), 'utf-8')
+ serializer = PharmacodynamicSbmlSerializer(
+ pd_model,
+ data={"sbml": sbml_str},
+ partial=True
+ )
+ self.assertTrue(serializer.is_valid())
+ serializer.save()
+
+ def test_bad_sbml(self):
+ pd_model = PharmacodynamicModel.objects.create(
+ name='test'
+ )
+ serializer = PharmacodynamicSbmlSerializer(
+ pd_model,
+ data={"sbml": "bad sbml"},
+ partial=True
+ )
+ self.assertFalse(serializer.is_valid())
+
+ def test_bad_mmt(self):
+ pd_model = PharmacodynamicModel.objects.create(
+ name='test'
+ )
+ serializer = PharmacodynamicSerializer(
+ pd_model,
+ data={"mmt": "bad sbml"},
+ partial=True
+ )
+ self.assertFalse(serializer.is_valid())
diff --git a/pkpdapp/pkpdapp/tests/test_serializers/test_monolix.py b/pkpdapp/pkpdapp/tests/test_serializers/test_monolix.py
new file mode 100644
index 00000000..ac347943
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_serializers/test_monolix.py
@@ -0,0 +1,62 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import pkpdapp.tests # noqa: F401
+from django.core.files.uploadedfile import SimpleUploadedFile
+from django.test import TestCase
+import urllib.request
+from pkpdapp.models import (
+ Project, Compound,
+)
+from pkpdapp.api.serializers import (
+ MonolixSerializer,
+)
+
+BASE_URL_DATASETS = 'https://raw.githubusercontent.com/pkpdapp-team/pkpdapp-datafiles/main/' # noqa: E501
+
+
+class TestMonolixSerializer(TestCase):
+ def test_import(self):
+ compound = Compound.objects.create(
+ name='test',
+ description='test',
+ molecular_mass=100,
+ target_molecular_mass=100,
+ )
+ project = Project.objects.create(
+ name='test',
+ compound=compound,
+ )
+ model_f = urllib.request.urlopen(
+ BASE_URL_DATASETS + 'usecase_monolix/PK_Model.txt', timeout=5
+ )
+ project_f = urllib.request.urlopen(
+ BASE_URL_DATASETS + 'usecase_monolix/Model_208.mlxtran', timeout=5
+ )
+ data_f = urllib.request.urlopen(
+ BASE_URL_DATASETS + 'usecase_monolix/TE_Data.txt', timeout=5
+ )
+
+ files = []
+ for f, n in zip(
+ [model_f, project_f, data_f],
+ ['model_txt', 'project_mlxtran', 'data_csv']
+ ):
+ content = SimpleUploadedFile(n, f.read())
+ files.append(content)
+
+ data = {
+ 'model_txt': files[0],
+ 'project_mlxtran': files[1],
+ 'data_csv': files[2],
+ }
+ serializer = MonolixSerializer(project, data=data)
+ print(serializer.is_valid())
+ print(serializer.errors)
+ self.assertTrue(serializer.is_valid())
+ serializer.save()
+ self.assertIn('pd_model', serializer.data)
+ self.assertIn('pk_model', serializer.data)
+ self.assertIn('data', serializer.data)
diff --git a/pkpdapp/pkpdapp/tests/test_utils/test_data_parser.py b/pkpdapp/pkpdapp/tests/test_utils/test_data_parser.py
new file mode 100644
index 00000000..088dc749
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_utils/test_data_parser.py
@@ -0,0 +1,130 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import django
+import codecs
+from django.utils import timezone
+import urllib.request
+from django.test import TestCase
+from pkpdapp.models.dataset import Dataset
+from pkpdapp.utils import DataParser
+
+django.setup()
+BASE_URL_DATASETS = 'https://raw.githubusercontent.com/pkpdapp-team/pkpdapp-datafiles/main/' # noqa: E501
+
+
+class TestDataParser(TestCase):
+ def test_parse(self):
+ for filename in [
+ 'datasets/TCB4dataset.csv',
+ 'datasets/demo_pk_data_upload.csv',
+ 'usecase_monolix/TE_Data.txt',
+ 'usecase0/usecase0.csv',
+ 'usecase1/usecase1.csv',
+ 'usecase2/PKPD_UseCase_Abx.csv',
+
+ ]:
+ with urllib.request.urlopen(
+ BASE_URL_DATASETS + filename, timeout=5
+ ) as f:
+ csv_str = codecs.decode(f.read(), 'utf-8')
+ parser = DataParser()
+ if filename == 'usecase_monolix/TE_Data.txt':
+ data = parser.parse_from_str(csv_str, delimiter='\t')
+ else:
+ data = parser.parse_from_str(csv_str)
+ expected = [
+ "SUBJECT_ID", "TIME", "AMOUNT", "OBSERVATION",
+ "TIME_UNIT", "AMOUNT_UNIT", "OBSERVATION_UNIT",
+ "OBSERVATION_NAME", "COMPOUND", "ROUTE", "INFUSION_TIME",
+ ]
+ for col in expected:
+ self.assertIn(col, data.columns.tolist())
+
+ dataset = Dataset.objects.create(
+ name=filename,
+ datetime=timezone.now(),
+ )
+ dataset.replace_data(data)
+
+ if filename == 'datasets/TCB4dataset.csv':
+ biomarker_types_in_file = [
+ 'IL2', 'IL10', 'IL6', 'IFNg', 'TNFa', 'Cells'
+ ]
+ covariate_columns = [
+ 'SUBJECT_GROUP', 'DOSE_GROUP', 'CL', 'YTYPE',
+ 'mdv', 'STUDYID'
+ ]
+ self.assertCountEqual(
+ biomarker_types_in_file + covariate_columns,
+ dataset.biomarker_types.values_list('name', flat=True),
+ )
+
+ if filename == 'usecase0/usecase0.csv':
+ # check that categorical covariate SEX is added
+ self.assertIn(
+ "SEX",
+ dataset.biomarker_types.values_list(
+ 'name', flat=True
+ )
+ )
+
+ # check that SEX is "Male" for single subjects
+ sex_bt = dataset.biomarker_types.get(name="SEX")
+ sex_data = sex_bt.data()
+ self.assertEqual(len(sex_data["values"]), 1)
+ self.assertEqual(sex_data["values"].iloc[0], "Male")
+
+ # default display for covariates is false
+ self.assertFalse(sex_bt.display)
+
+ if filename == 'datasets/demo_pk_data_upload.csv':
+
+ # check the right biomarker_types are there
+ biomarker_types_in_file = [
+ 'Docetaxel', 'Red blood cells', 'Hemoglobin',
+ 'Platelets ', 'White blood cells',
+ 'Neutrophiles absolute', 'Lymphocytes absolute',
+ 'Monocytes absolute', 'Eosinophils absolute',
+ 'Basophils absolute',
+ ]
+ covariate_columns = [
+ 'DOSE',
+ 'EVID',
+ 'CENS',
+ 'WT',
+ 'YTYPE',
+ 'MDV',
+ 'STUDYID',
+ 'SPECIES',
+ 'SEX',
+ 'SUBJECT_GROUP',
+ 'STUDYID.1',
+ 'DOSE_GROUP',
+ ]
+ self.assertCountEqual(
+ dataset.biomarker_types.values_list('name', flat=True),
+ biomarker_types_in_file + covariate_columns
+ )
+
+ # check the right number of subjects and protocols added
+ self.assertEqual(dataset.subjects.count(), 66)
+ protocols = set([
+ subject.protocol for subject in dataset.subjects.all()
+ ])
+ self.assertEqual(len(protocols), 39)
+ if filename == 'usecase_monolix/TE_Data.txt':
+ expected_names = [
+ 'observation', 'Dose', 'Dose_units', 'Dose_cat'
+ ]
+ biomarker_names = dataset.biomarker_types.values_list(
+ 'name', flat=True
+ )
+ self.assertCountEqual(biomarker_names, expected_names)
+ expected_units = ['', '', '', '']
+ biomarker_units = dataset.biomarker_types.values_list(
+ 'stored_unit__symbol', flat=True
+ )
+ self.assertCountEqual(biomarker_units, expected_units)
diff --git a/pkpdapp/pkpdapp/tests/test_utils/test_monolix_import.py b/pkpdapp/pkpdapp/tests/test_utils/test_monolix_import.py
new file mode 100644
index 00000000..c38404fb
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_utils/test_monolix_import.py
@@ -0,0 +1,93 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import django
+import codecs
+import urllib.request
+from django.test import TestCase
+from pkpdapp.models import (
+ Project
+)
+
+from pkpdapp.utils import (
+ monolix_import
+)
+
+django.setup()
+BASE_URL_DATASETS = 'https://raw.githubusercontent.com/pkpdapp-team/pkpdapp-datafiles/main/' # noqa: E501
+
+
+class TestMonolixImport(TestCase):
+ def test_import_project(self):
+ project = Project.objects.create(
+ name='test',
+ )
+ with urllib.request.urlopen(
+ BASE_URL_DATASETS + 'usecase_monolix/PK_Model.txt', timeout=5
+ ) as f:
+ monolix_model_str = codecs.decode(f.read(), 'utf-8')
+ with urllib.request.urlopen(
+ BASE_URL_DATASETS + 'usecase_monolix/Model_208.mlxtran', timeout=5
+ ) as f:
+ monolix_project_str = codecs.decode(f.read(), 'ascii')
+ with urllib.request.urlopen(
+ BASE_URL_DATASETS + 'usecase_monolix/TE_Data.txt', timeout=5
+ ) as f:
+ monolix_data_str = codecs.decode(f.read(), 'utf-8')
+
+ result = monolix_import(
+ project, monolix_project_str,
+ monolix_model_str, monolix_data_str, validate=False
+ )
+ self.assertIsNotNone(result)
+ pd_model, pk_model, dataset = result
+ constant_variables = pd_model.variables.filter(
+ constant=True).values_list('qname', flat=True)
+ expected_constant_variables = [
+ 'root.Cl', 'root.KD', 'root.R0', 'root.V', 'root.fres',
+ 'root.hind', 'root.ka', 'root.kdeg', 'root.koff'
+ ]
+ self.assertCountEqual(constant_variables, expected_constant_variables)
+ state_variables = pd_model.variables.filter(
+ state=True).values_list('qname', flat=True)
+ expected_state_variables = ['cmt1.A1', 'root.A2', 'root.A4', 'root.A5']
+ self.assertCountEqual(state_variables, expected_state_variables)
+ other_variables = pd_model.variables.filter(
+ constant=False, state=False).values_list('qname', flat=True)
+ expected_other_variables = [
+ 'root.A3', 'root.C2', 'root.C3', 'root.C4', 'root.C5',
+ 'root.CD_t', 'root.CR_t', 'root.PRR', 'root.RR', 'root.t'
+ ]
+ self.assertCountEqual(other_variables, expected_other_variables)
+ self.assertEqual(pk_model.dose_compartment, 'cmt1')
+
+ displayed_biomarkers = dataset.biomarker_types.filter(
+ display=True
+ ).values_list('name', flat=True)
+ expected_biomarkers = ['observation']
+ self.assertCountEqual(displayed_biomarkers, expected_biomarkers)
+ displayed_pd_variables = pd_model.variables.filter(
+ constant=False, display=True
+ ).values_list('qname', flat=True)
+ displayed_pk_variables = pk_model.variables.filter(
+ constant=False, display=True
+ ).values_list('qname', flat=True)
+ expected_variables = ['root.PRR']
+ self.assertCountEqual(displayed_pd_variables, expected_variables)
+ self.assertCountEqual(displayed_pk_variables, expected_variables)
+
+ pd_states = pd_model.variables.filter(
+ state=True
+ ).values_list('qname', flat=True)
+ pk_states = pk_model.variables.filter(
+ state=True
+ ).values_list('qname', flat=True)
+ expected_states = ['cmt1.A1', 'root.A2', 'root.A4', 'root.A5']
+ self.assertCountEqual(pd_states, expected_states)
+ self.assertCountEqual(pk_states, expected_states)
+
+ result = pk_model.simulate()
+ print(result)
diff --git a/pkpdapp/pkpdapp/tests/test_utils/test_monolix_parser.py b/pkpdapp/pkpdapp/tests/test_utils/test_monolix_parser.py
new file mode 100644
index 00000000..eb7b1644
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_utils/test_monolix_parser.py
@@ -0,0 +1,49 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import django
+import codecs
+import unittest
+import urllib.request
+from pkpdapp.utils import (
+ MonolixModelParser, MonolixProjectParser
+)
+
+django.setup()
+BASE_URL_DATASETS = 'https://raw.githubusercontent.com/pkpdapp-team/pkpdapp-datafiles/main/' # noqa: E501
+
+
+class TestMonolixParser(unittest.TestCase):
+ def test_parse_model(self):
+ with urllib.request.urlopen(
+ BASE_URL_DATASETS + 'usecase_monolix/PK_Model.txt', timeout=5
+ ) as f:
+ monolix_str = codecs.decode(f.read(), 'utf-8')
+ parser = MonolixModelParser()
+ model, (admin_id, tlag, direct) = parser.parse(monolix_str)
+ model.validate()
+ self.assertEqual(admin_id, 1)
+ self.assertEqual(tlag, 0)
+ self.assertEqual(direct, True)
+
+ def test_parse_project(self):
+ with urllib.request.urlopen(
+ BASE_URL_DATASETS + 'usecase_monolix/Model_208.mlxtran', timeout=5
+ ) as f:
+ monolix_str = codecs.decode(f.read(), 'ascii')
+ parser = MonolixProjectParser()
+ project = parser.parse(monolix_str)
+ self.assertCountEqual(
+ project.keys(),
+ ['', '', '', '', '', ]
+ )
+ self.assertCountEqual(
+ project[''].keys(),
+ ['[CONTENT]', '[FILEINFO]']
+ )
+ self.assertCountEqual(
+ project[''].keys(),
+ ['[COVARIATE]', '[INDIVIDUAL]', '[LONGITUDINAL]']
+ )
diff --git a/pkpdapp/pkpdapp/tests/test_views/__init__.py b/pkpdapp/pkpdapp/tests/test_views/__init__.py
new file mode 100644
index 00000000..d0505307
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/__init__.py
@@ -0,0 +1,5 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_auce.py b/pkpdapp/pkpdapp/tests/test_views/test_auce.py
new file mode 100644
index 00000000..c726ce1c
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_auce.py
@@ -0,0 +1,68 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+from rest_framework import status
+from rest_framework.test import APITestCase, APIClient
+from django.contrib.auth.models import User
+from pkpdapp.models import BiomarkerType, Dataset
+import unittest
+
+
+@unittest.skip("might not be needed anymore")
+class NcaTestCase(APITestCase):
+ def setUp(self):
+ user = User.objects.get(username='demo')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_auce_post(self):
+ dataset = Dataset.objects.get(
+ name='TCB4dataset'
+ )
+ biomarker_type = BiomarkerType.objects.get(
+ name='IL2',
+ dataset=dataset,
+ )
+ group_type = BiomarkerType.objects.get(
+ name='group',
+ dataset=dataset,
+ )
+ dose_type = BiomarkerType.objects.get(
+ name='dose',
+ dataset=dataset,
+ )
+ data = {
+ 'biomarker_type_id': biomarker_type.id,
+ 'group_type_id': group_type.id,
+ 'concentration_type_id': dose_type.id,
+ }
+ response = self.client.post(
+ "/api/auce/", data
+ )
+ self.assertEqual(
+ response.status_code, status.HTTP_200_OK
+ )
+
+ def test_auce_no_dose_group_amount(self):
+ biomarker_type = BiomarkerType.objects.get(
+ name='Docetaxel'
+ )
+ data = {
+ 'biomarker_type_id': biomarker_type.id,
+ }
+ response = self.client.post(
+ "/api/auce/", data
+ )
+ self.assertEqual(
+ response.status_code, status.HTTP_400_BAD_REQUEST
+ )
+ self.assertRegex(
+ response.data['group_type_id'],
+ (
+ 'required'
+ )
+ )
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_biomarker_type.py b/pkpdapp/pkpdapp/tests/test_views/test_biomarker_type.py
new file mode 100644
index 00000000..56ae56d1
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_biomarker_type.py
@@ -0,0 +1,27 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import pkpdapp.tests # noqa: F401
+import django
+from django.contrib.auth.models import User
+from rest_framework import status
+from rest_framework.test import APIClient, APITestCase
+from pkpdapp.models import Project
+django.setup()
+
+
+class BiomarkerTypeTestCase(APITestCase):
+ def setUp(self):
+ user = User.objects.get(username='demo')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_bt_project_filter(self):
+ project = Project.objects.get(name="demo")
+ response = self.client.get(
+ "/api/biomarker_type/?project_id={}".format(project.pk)
+ )
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ self.assertTrue(len(response.data) == 0)
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_combined_model.py b/pkpdapp/pkpdapp/tests/test_views/test_combined_model.py
new file mode 100644
index 00000000..1fb18cd2
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_combined_model.py
@@ -0,0 +1,177 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+from rest_framework import status
+from rest_framework.test import APITestCase, APIClient
+from django.contrib.auth.models import User
+from pkpdapp.models import (
+ Project,
+ PharmacokineticModel,
+ CombinedModel,
+ PharmacodynamicModel,
+)
+import numpy as np
+
+
+class CombinedModelTestCase(APITestCase):
+ def setUp(self):
+ user = User.objects.get(username="demo")
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_pk_project_filter(self):
+ response = self.client.get("/api/combined_model/?project_id=1")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ response_data = response.data
+ self.assertEqual(len(response_data), 1)
+
+ def test_cannot_create_in_read_only_project(self):
+ user = User.objects.get(username="demo2")
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ project = Project.objects.get(name="demo")
+ response = self.client.post(
+ "/api/combined_model/", data={"name": "test", "project": project.id}
+ )
+ self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+ def create_combined_model(self, name, pd=None):
+ project = Project.objects.get(name="demo")
+ pk = PharmacokineticModel.objects.get(
+ name="one_compartment_clinical",
+ )
+ data = {
+ "name": name,
+ "project": project.id,
+ "pk_model": pk.id,
+ "mappings": [],
+ "derived_variables": [],
+ }
+ if pd is not None:
+ data["pd_model"] = pd.id
+ response = self.client.post("/api/combined_model/", data=data, format="json")
+ self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+ cm = CombinedModel.objects.get(pk=response.data["id"])
+
+ # set up a protocol
+ response = self.client.post(
+ "/api/protocol/",
+ data={
+ "name": "test protocol",
+ "project": project.id,
+ "doses": [
+ {
+ "start_time": 0,
+ "amount": 1,
+ "duration": 0.001,
+ "repeat_interval": 1,
+ "repeats": 1,
+ }
+ ],
+ },
+ format="json",
+ )
+ self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+ # attach it to the A1 variables
+ a1 = cm.variables.get(name="A1")
+ response = self.client.patch(
+ f"/api/variable/{a1.id}/",
+ data={
+ "protocol": response.data["id"],
+ },
+ format="json",
+ )
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+ if pd is not None:
+ c1 = cm.variables.get(name="C1")
+ drug_c = cm.variables.get(name="C_Drug")
+
+ response = self.client.patch(
+ f"/api/combined_model/{cm.id}/",
+ data={
+ "mappings": [
+ {
+ "pk_variable": c1.id,
+ "pd_variable": drug_c.id,
+ }
+ ],
+ "derived_variables": [],
+ },
+ format="json",
+ )
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+ return response.data
+
+ def simulate_combined_model(self, id):
+ response = self.client.post(
+ f"/api/combined_model/{id}/simulate",
+ data={
+ "outputs": [
+ "PDCompartment.C_Drug",
+ "PKCompartment.C1",
+ "PDCompartment.E",
+ ],
+ "variables": {},
+ },
+ format="json",
+ )
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ keys = [key for key in response.data["outputs"].keys()]
+ return (
+ response.data["outputs"][keys[0]],
+ response.data["outputs"][keys[1]],
+ response.data["outputs"][keys[2]],
+ )
+
+ def test_swap_mapped_pd_model(self):
+ pd1 = PharmacodynamicModel.objects.get(
+ name="indirect_effects_stimulation_elimination",
+ )
+ pd2 = PharmacodynamicModel.objects.get(
+ name="indirect_effects_inhibition_elimination",
+ )
+ model1 = self.create_combined_model("test1", pd1)
+ model2 = self.create_combined_model("test2", pd2)
+ c_drug1, c1_1, e1 = self.simulate_combined_model(model1["id"])
+ c_drug2, c1_2, e2 = self.simulate_combined_model(model2["id"])
+
+ # c_drug should be mapped to c1 and equal
+ np.testing.assert_allclose(c_drug1, c1_1, atol=1e-5, rtol=1e-5)
+
+ # swap the pd model for model 1, old mappings should be updated
+ cm = CombinedModel.objects.get(pk=model1["id"])
+ c1 = cm.variables.get(name="C1")
+ c_drug = cm.variables.get(name="C_Drug")
+ response = self.client.patch(
+ f"/api/combined_model/{model1['id']}/",
+ data={
+ "pd_model": pd2.id,
+ "mappings": [
+ {
+ "pk_variable": c1.id,
+ "pd_variable": c_drug.id,
+ }
+ ],
+ },
+ format="json",
+ )
+ model1 = response.data
+
+ # simulate the model again
+ c_drug3, c1_3, e3 = self.simulate_combined_model(model1["id"])
+
+ # c_drug3 should be mapped to c3 and equal
+ np.testing.assert_allclose(c_drug3, c1_3, atol=1e-5, rtol=1e-5)
+
+ # check that the data is the same as the second simulation
+ np.testing.assert_allclose(c_drug3, c_drug2, atol=1e-5, rtol=1e-5)
+ np.testing.assert_allclose(c1_3, c1_2, atol=1e-5, rtol=1e-5)
+ np.testing.assert_allclose(e3, e2, atol=1e-5, rtol=1e-5)
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_dataset.py b/pkpdapp/pkpdapp/tests/test_views/test_dataset.py
new file mode 100644
index 00000000..c306a2fc
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_dataset.py
@@ -0,0 +1,49 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import pkpdapp.tests # noqa: F401
+from urllib.request import urlretrieve
+
+from django.contrib.auth.models import User
+from django.core.files import File
+from rest_framework import status
+from rest_framework.test import APIClient, APITestCase
+
+BASE_URL_DATASETS = 'https://raw.githubusercontent.com/pkpdapp-team/pkpdapp-datafiles/main/datasets/' # noqa: E501
+BASE_URL_MODELS = 'https://raw.githubusercontent.com/pkpdapp-team/pkpdapp-datafiles/main/models/' # noqa: E501
+
+
+def faux_test_file(url, ending='.csv'):
+ tempname, _ = urlretrieve(url)
+ file = File(open(tempname, 'rb'))
+ file.name = 'test' + ending
+ return file
+
+
+class DatasetTestCase(APITestCase):
+ def setUp(self):
+ user = User.objects.get(username='demo')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_dataset_creation(self):
+ data = {"name": "hello", "datatime": "", "description": "bye"}
+ response = self.client.post("/api/dataset/", data)
+ self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+ response_data = response.data
+ self.assertEqual(response_data["name"], data["name"])
+ self.assertEqual(response_data["description"], data["description"])
+
+ keys = response_data.keys()
+ present_keys = ['name', 'datetime', 'description', 'subjects',
+ 'biomarker_types']
+ for k in present_keys:
+ self.assertTrue(k in keys)
+
+ def test_dataset_project_filter(self):
+ response = self.client.get("/api/dataset/?project_id=1")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ response_data = response.data
+ self.assertEqual(len(response_data), 0)
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_inference.py b/pkpdapp/pkpdapp/tests/test_views/test_inference.py
new file mode 100644
index 00000000..2685d84e
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_inference.py
@@ -0,0 +1,361 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import status
+
+from django.contrib.auth.models import User
+from rest_framework.test import APIClient, APITestCase
+
+from pkpdapp.models import (
+ Algorithm,
+ Inference,
+ InferenceMixin,
+ Project,
+)
+from pkpdapp.tests import create_pd_inference
+
+
+class TestInferenceWizardView(APITestCase):
+ def setUp(self):
+ self.project = Project.objects.get(
+ name='demo',
+ )
+
+ user = User.objects.get(username='demo')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_population_and_covariates_inference(self):
+ inference, log_likelihood, \
+ biomarker_type, covariate_biomarker_type, \
+ pd_model, pd_dataset = create_pd_inference(
+ sampling=False)
+
+ pd_biomarker_names = [
+ biomarker_type.name,
+ covariate_biomarker_type.name,
+ ]
+
+ pd_output_name = log_likelihood.parents.first().name
+ pd_parameter_names = [
+ v.qname for v in pd_model.variables.filter(constant=True)
+ ]
+ data = {
+ # Inference parameters
+ 'name': "my inference run",
+ 'project': 1,
+ 'algorithm': 1,
+ 'initialization_strategy': 'R',
+ 'number_of_chains': 4,
+ 'max_number_of_iterations': 3000,
+ 'burn_in': 0,
+
+ # Model
+ 'model': {
+ 'form': 'PK',
+ 'id': pd_model.id
+ },
+ 'dataset': pd_dataset.id,
+ 'grouping': 'subject',
+
+ # Model parameters
+ 'parameters': [
+ {
+ 'name': pd_parameter_names[0],
+ 'form': 'N',
+ 'pooled': False,
+ 'parameters': [
+ (
+ r'0.1 * biomarker("{}") + '
+ r'parameter("population_parameter")'
+ .format(pd_biomarker_names[1])
+ ),
+ 0.1
+ ]
+ },
+ {
+ 'name': 'population_parameter',
+ 'form': 'N',
+ 'parameters': [1, 0.1]
+ },
+ ],
+
+ # output
+ 'observations': [
+ {
+ 'model': pd_output_name,
+ 'biomarker': pd_biomarker_names[0],
+ 'noise_form': 'N',
+ 'noise_param_form': 'N',
+ 'parameters': [0, 1]
+ },
+ ]
+ }
+ print(data)
+ response = self.client.post(
+ "/api/inference/wizard", data, format='json'
+ )
+
+ response_data = response.data
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+ # check inference fields
+ self.assertEqual(response_data['name'], 'my inference run')
+ self.assertEqual(response_data['project'], self.project.id)
+ self.assertEqual(response_data['initialization_strategy'], 'R')
+
+ # check number of log_likelihoods, and that the population_parameter is
+ # there
+ self.assertEqual(len(response_data['log_likelihoods']), 14)
+ found_it = False
+ for ll in response_data['log_likelihoods']:
+ if ll['name'] == 'population_parameter':
+ found_it = True
+ self.assertEqual(len(ll['parameters']), 2)
+ self.assertTrue(found_it)
+
+ # check that the equation log_likelihood looks ok
+ found_it = False
+ for ll in response_data['log_likelihoods']:
+ if ll['name'] == 'mean for ' + pd_parameter_names[0]:
+ found_it = True
+ self.assertEqual(len(ll['parameters']), 2)
+ self.assertTrue(
+ ll['description'] == '0.1 * arg0 + arg1' or
+ ll['description'] == '0.1 * arg1 + arg0'
+ )
+ self.assertTrue(found_it)
+
+ inference = Inference.objects.get(id=response_data['id'])
+
+ inference_mixin = InferenceMixin(inference)
+ log_posterior = inference_mixin._pints_log_posterior
+
+ # pymc3_model = log_posterior._model
+ # graph = pymc3.model_graph.model_to_graphviz(pymc3_model)
+ # graph.render(directory='test', view=True)
+
+ log_posterior(
+ log_posterior.to_search([0.5] * log_posterior.n_parameters())
+ )
+
+ def test_pd_inference_runs(self):
+ inference, log_likelihood, \
+ biomarker_type, \
+ covariate_biomarker_type, \
+ pd_model, pd_dataset = create_pd_inference(
+ sampling=False)
+
+ pd_biomarker_name = biomarker_type.name
+ pd_output_name = log_likelihood.parents.first().name
+ pd_parameter_names = [
+ v.qname for v in pd_model.variables.filter(constant=True)
+ ]
+
+ data = {
+ # Inference parameters
+ 'name': "test inference run",
+ 'project': self.project.id,
+ 'algorithm': Algorithm.objects.get(name='XNES').id,
+ 'initialization_strategy': 'R',
+ 'number_of_chains': 4,
+ 'max_number_of_iterations': 11,
+ 'burn_in': 0,
+
+ # Model
+ 'model': {
+ 'form': 'PD',
+ 'id': pd_model.id
+ },
+ 'dataset': pd_dataset.id,
+
+ # Model parameters
+ 'parameters': [
+ {
+ 'name': pd_parameter_names[0],
+ 'form': 'N',
+ 'parameters': [1, 0.1],
+ },
+ {
+ 'name': pd_parameter_names[1],
+ 'form': 'U',
+ 'parameters': [0.1, 0.2],
+ },
+ {
+ 'name': pd_parameter_names[2],
+ 'form': 'F',
+ 'parameters': [0.1],
+ }
+ ],
+ # output
+ 'observations': [
+ {
+ 'model': pd_output_name,
+ 'biomarker': pd_biomarker_name,
+ 'noise_form': 'N',
+ 'noise_param_form': 'N',
+ 'parameters': [0, 1],
+ },
+ ]
+ }
+ response = self.client.post(
+ "/api/inference/wizard", data, format='json'
+ )
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ response_data = response.data
+
+ # check inference fields
+ self.assertEqual(response_data['name'], 'test inference run')
+ self.assertEqual(response_data['project'], self.project.id)
+ self.assertEqual(response_data['initialization_strategy'], 'R')
+
+ # check number of log_likelihoods, and that the model ll is there
+ self.assertEqual(len(response_data['log_likelihoods']), 12)
+ found_it = False
+ for ll in response_data['log_likelihoods']:
+ print('looking in ', ll['name'])
+ if ll['name'] == 'my wonderful model':
+ found_it = True
+ self.assertEqual(len(ll['parameters']), 3)
+ model_id = ll['id']
+ self.assertTrue(found_it)
+
+ # check that the output log_likelihood is there and looks ok
+ found_it = False
+ for ll in response_data['log_likelihoods']:
+ if ll['name'] == pd_output_name:
+ found_it = True
+ self.assertEqual(len(ll['parameters']), 2)
+ self.assertEqual(ll['parameters'][0]['name'],
+ pd_output_name)
+ self.assertEqual(ll['form'], 'N')
+ self.assertEqual(
+ ll['biomarker_type'],
+ pd_dataset.biomarker_types.get(name=pd_biomarker_name).id
+ )
+ self.assertEqual(ll['parameters'][0]['child'], model_id)
+ sigma_ll = ll['parameters'][1]['child']
+ self.assertTrue(found_it)
+
+ # check that the sigma log_likelihood is there and looks ok
+ found_it = False
+ for ll in response_data['log_likelihoods']:
+ if ll['id'] == sigma_ll:
+ found_it = True
+ self.assertEqual(ll['form'], 'N')
+ self.assertEqual(len(ll['parameters']), 2)
+ self.assertTrue(found_it)
+
+ # check that the param 1 log_likelihood is there and looks ok
+ found_it = False
+ for ll in response_data['log_likelihoods']:
+ if ll['name'] == pd_parameter_names[1]:
+ found_it = True
+ self.assertEqual(ll['form'], 'U')
+ self.assertEqual(len(ll['parameters']), 2)
+ child_id = ll['parameters'][0]['child']
+ self.assertTrue(found_it)
+ found_it = False
+ for ll in response_data['log_likelihoods']:
+ if ll['id'] == child_id:
+ found_it = True
+ self.assertEqual(ll['form'], 'F')
+ self.assertEqual(ll['value'], 0.1)
+ self.assertTrue(found_it)
+
+ inference = Inference.objects.get(id=response_data['id'])
+
+ inference_mixin = InferenceMixin(inference)
+ log_posterior = inference_mixin._pints_log_posterior
+
+ # pymc3_model = log_posterior._model
+ # graph = pymc3.model_graph.model_to_graphviz(pymc3_model)
+ # graph.render(directory='test', view=True)
+
+ log_posterior(
+ log_posterior.to_search([0.5, 0.12, 0.1])
+ )
+
+ def test_errors(self):
+ inference, log_likelihood, biomarker_type, \
+ covariate_biomarker_type, pd_model, \
+ pd_dataset = create_pd_inference(
+ sampling=False)
+
+ pd_parameter_names = [
+ v.qname for v in pd_model.variables.filter(constant=True)
+ ]
+
+ data = {}
+ response = self.client.post(
+ "/api/inference/wizard", data, format='json'
+ )
+ self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+ self.assertIn('project', response.data)
+ self.assertIn('dataset', response.data)
+ self.assertIn('model', response.data)
+ self.assertIn('parameters', response.data)
+ self.assertIn('observations', response.data)
+
+ data = {
+ 'name': "test inference run",
+ 'project': self.project.id,
+ 'algorithm': Algorithm.objects.get(name='XNES').id,
+ 'initialization_strategy': 'R',
+ 'number_of_chains': 4,
+ 'max_number_of_iterations': 2,
+ 'burn_in': 0,
+
+ 'model': {
+ 'form': 'PD',
+ 'id': pd_model.id
+ },
+ 'dataset': pd_dataset.id,
+
+ 'parameters': [
+ {
+ 'name': pd_parameter_names[0],
+ 'form': 'N',
+ 'parameters': ['import pybamm', 1],
+ },
+ {
+ 'name': pd_parameter_names[1],
+ 'form': 'N',
+ 'parameters': ['1 + parameter("doesnt exist")', 1],
+ },
+ {
+ 'name': pd_parameter_names[2],
+ 'form': 'N',
+ 'parameters': ['1 + biomarker("doesnt exist")', 1],
+ },
+ ],
+ 'observations': [
+ {
+ 'model': 'not in the model, really',
+ 'biomarker': 'not in the dataset',
+ 'noise_form': 'N',
+ 'noise_param_form': 'N',
+ 'parameters': [0, 1],
+ },
+ ]
+ }
+
+ response = self.client.post(
+ "/api/inference/wizard", data, format='json'
+ )
+ self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+ self.assertIn(
+ 'Expected', response.data['parameters'][0]['parameters'][0]
+ )
+ self.assertIn(
+ 'not in list of parameters',
+ response.data['parameters'][1]['parameters'][0]
+ )
+ self.assertIn(
+ 'not in list of biomarkers',
+ response.data['parameters'][2]['parameters'][0]
+ )
+ self.assertIn('model', response.data['observations'][0])
+ self.assertIn('biomarker', response.data['observations'][0])
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_nca.py b/pkpdapp/pkpdapp/tests/test_views/test_nca.py
new file mode 100644
index 00000000..563612a0
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_nca.py
@@ -0,0 +1,66 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+import unittest
+from rest_framework import status
+from rest_framework.test import APITestCase, APIClient
+from django.contrib.auth.models import User
+from pkpdapp.models import BiomarkerType, Protocol
+
+
+@unittest.skip("NCA deprecated")
+class NcaTestCase(APITestCase):
+ def setUp(self):
+ user = User.objects.get(username='demo')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_nca_post(self):
+ biomarker_type = BiomarkerType.objects.get(
+ name='Docetaxel'
+ )
+ protocol = Protocol.objects.get(
+ name='demo_pk_data-Docetaxel-5335'
+ )
+ subject = protocol.subjects.first()
+ data = {
+ 'subject_id': subject.id,
+ 'biomarker_type_id': biomarker_type.id,
+ }
+ response = self.client.post(
+ "/api/nca/", data
+ )
+ self.assertEqual(
+ response.status_code, status.HTTP_200_OK
+ )
+
+ def test_nca_post_fail_no_subject(self):
+ biomarker_type = BiomarkerType.objects.get(
+ name='Docetaxel'
+ )
+ protocol = Protocol.objects.get(
+ name='demo_pk_data-Docetaxel-5109'
+ )
+ subject = protocol.subjects.first()
+ data = {
+ 'subject_id': subject.id,
+ 'biomarker_type_id': biomarker_type.id,
+ }
+ response = self.client.post(
+ "/api/nca/", data
+ )
+ self.assertEqual(
+ response.status_code, status.HTTP_400_BAD_REQUEST
+ )
+ self.assertRegex(
+ response.data['biomarker_type'],
+ (
+ "BiomarkerType {} does not have measurements "
+ "for subject id"
+ .format(biomarker_type.id)
+ )
+ )
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_pd_model.py b/pkpdapp/pkpdapp/tests/test_views/test_pd_model.py
new file mode 100644
index 00000000..d9f1f03b
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_pd_model.py
@@ -0,0 +1,56 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pkpdapp.tests # noqa: F401
+from rest_framework import status
+from rest_framework.test import APITestCase, APIClient
+from django.contrib.auth.models import User
+from pkpdapp.models import Project
+
+
+class PdModelTestCase(APITestCase):
+ def setUp(self):
+ user = User.objects.get(username='demo')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_pd_project_filter(self):
+ response = self.client.get("/api/pharmacodynamic/?project_id=1")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ response_data = response.data
+ self.assertEqual(len(response_data), 0)
+
+ def test_pd_serializer(self):
+ response = self.client.get("/api/pharmacodynamic/1/")
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+ def test_cannot_edit_read_only_project(self):
+ user = User.objects.get(username='demo2')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ project = Project.objects.get(name='demo')
+ response = self.client.post(
+ "/api/pharmacodynamic/",
+ data={
+ 'name': 'test',
+ 'project': project.id
+ }
+ )
+ self.assertEqual(
+ response.status_code, status.HTTP_403_FORBIDDEN
+ )
+
+ response = self.client.put(
+ "/api/combined_model/1/",
+ data={
+ 'name': 'test',
+ 'project': project.id
+ }
+ )
+ self.assertEqual(
+ response.status_code, status.HTTP_403_FORBIDDEN
+ )
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_simulate.py b/pkpdapp/pkpdapp/tests/test_views/test_simulate.py
new file mode 100644
index 00000000..a15cbe06
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_simulate.py
@@ -0,0 +1,58 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from pkpdapp.models import (
+ PharmacodynamicModel, Variable,
+ CombinedModel,
+
+)
+from django.contrib.auth.models import User
+
+from rest_framework import status
+from django.urls import reverse
+
+from rest_framework.test import APITestCase, APIClient
+
+
+class TestSimulateView(APITestCase):
+ def setUp(self):
+ user = User.objects.get(username='demo')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_simulate(self):
+ pd = PharmacodynamicModel.objects.get(
+ name='tumour_growth_gompertz',
+ read_only=False,
+ )
+ m = CombinedModel.objects.create(
+ name='my wonderful model',
+ pd_model=pd,
+ )
+
+ url = reverse('simulate-combined-model', args=(m.pk,))
+ data = {
+ 'outputs': ['PDCompartment.TS', 'environment.t'],
+ 'variables': {
+ 'PDCompartment.TS0': 1.1,
+ },
+ }
+
+ response = self.client.post(url, data, format='json')
+
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ outputs = response.data.get('outputs')
+ self.assertCountEqual(
+ list(outputs.keys()),
+ [
+ Variable.objects.get(qname=qname, dosed_pk_model=m).id
+ for qname in data['outputs']
+ ]
+ )
+
+ url = reverse('simulate-combined-model', args=(123,))
+ response = self.client.post(url, data, format='json')
+ self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_unit.py b/pkpdapp/pkpdapp/tests/test_views/test_unit.py
new file mode 100644
index 00000000..ada81c0c
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_unit.py
@@ -0,0 +1,37 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import status
+from rest_framework.test import APITestCase, APIClient
+from django.contrib.auth.models import User
+from pkpdapp.models import (
+ PharmacodynamicModel, CombinedModel
+)
+
+
+class UnitTestCase(APITestCase):
+ def setUp(self):
+ self.pd_model = PharmacodynamicModel.objects.get(
+ name='tumour_growth_gompertz',
+ )
+
+ self.dosed_pk_model = \
+ CombinedModel.objects.create(
+ pd_model=self.pd_model,
+ )
+
+ user = User.objects.get(username='demo')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_dosed_pk_project_filter(self):
+ response = self.client.get(
+ "/api/unit/?dosed_pk_model_id={}".format(
+ self.dosed_pk_model.id
+ )
+ )
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ response_data = response.data
+ self.assertGreater(len(response_data), 0)
diff --git a/pkpdapp/pkpdapp/tests/test_views/test_variable.py b/pkpdapp/pkpdapp/tests/test_views/test_variable.py
new file mode 100644
index 00000000..d6773e78
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/test_views/test_variable.py
@@ -0,0 +1,37 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from rest_framework import status
+from rest_framework.test import APITestCase, APIClient
+from django.contrib.auth.models import User
+from pkpdapp.models import (
+ PharmacodynamicModel, CombinedModel
+)
+
+
+class VariableTestCase(APITestCase):
+ def setUp(self):
+ self.pd_model = PharmacodynamicModel.objects.get(
+ name='tumour_growth_gompertz',
+ )
+
+ self.dosed_pk_model = \
+ CombinedModel.objects.create(
+ pd_model=self.pd_model,
+ )
+
+ user = User.objects.get(username='demo')
+ self.client = APIClient()
+ self.client.force_authenticate(user=user)
+
+ def test_dosed_pk_project_filter(self):
+ response = self.client.get(
+ "/api/variable/?dosed_pk_model_id={}".format(
+ self.dosed_pk_model.id
+ )
+ )
+ self.assertEqual(response.status_code, status.HTTP_200_OK)
+ response_data = response.data
+ self.assertGreater(len(response_data), 0)
diff --git a/pkpdapp/pkpdapp/tests/utils.py b/pkpdapp/pkpdapp/tests/utils.py
new file mode 100644
index 00000000..6bd3c89d
--- /dev/null
+++ b/pkpdapp/pkpdapp/tests/utils.py
@@ -0,0 +1,123 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+from pkpdapp.models import (
+ Inference, PharmacodynamicModel,
+ CombinedModel,
+ Unit,
+ LogLikelihood,
+ Project, BiomarkerType, Biomarker,
+ Algorithm,
+ Dataset,
+ Subject,
+)
+
+
+def create_pd_inference(sampling=False):
+ project = Project.objects.get(
+ name='demo',
+ )
+ pd = PharmacodynamicModel.objects.get(
+ name='tumour_growth_gompertz',
+ read_only=False,
+ )
+ model = CombinedModel.objects.create(
+ name='my wonderful model',
+ pd_model=pd,
+ )
+ # generate some fake data
+ output = model.variables.get(qname='PDCompartment.TS')
+ time = model.variables.get(qname='environment.t')
+ data = model.simulate(outputs=[output.qname, time.qname])
+ print(data)
+ TS = data[output.id]
+ times = data[time.id]
+ dataset = Dataset.objects.create(
+ name='fake data',
+ project=project,
+ )
+ bt = BiomarkerType.objects.create(
+ name='fake data',
+ dataset=dataset,
+ stored_unit=Unit.objects.get(symbol='mL'),
+ display_unit=Unit.objects.get(symbol='mL'),
+ stored_time_unit=Unit.objects.get(symbol='day'),
+ display_time_unit=Unit.objects.get(symbol='day'),
+ )
+ subject1 = Subject.objects.create(
+ id_in_dataset=1,
+ dataset=dataset,
+ )
+ subject2 = Subject.objects.create(
+ id_in_dataset=2,
+ dataset=dataset,
+ )
+
+ for i, (t, ts) in enumerate(zip(times, TS)):
+ Biomarker.objects.create(
+ biomarker_type=bt,
+ time=t,
+ value=ts,
+ subject=subject1,
+ )
+ Biomarker.objects.create(
+ biomarker_type=bt,
+ time=t,
+ value=ts,
+ subject=subject2,
+ )
+
+ bt_covariate = BiomarkerType.objects.create(
+ name='fake body weight',
+ dataset=dataset,
+ stored_unit=Unit.objects.get(symbol='kg'),
+ display_unit=Unit.objects.get(symbol='kg'),
+ stored_time_unit=Unit.objects.get(symbol='day'),
+ display_time_unit=Unit.objects.get(symbol='day'),
+ )
+
+ for s in [subject1, subject2]:
+ Biomarker.objects.create(
+ biomarker_type=bt_covariate,
+ time=0,
+ value=20,
+ subject=s,
+ )
+
+ algorithm = Algorithm.objects.get(
+ name='Haario-Bardenet') if sampling \
+ else Algorithm.objects.get(name='XNES')
+ inference = Inference.objects.create(
+ name='bob',
+ project=project,
+ max_number_of_iterations=10,
+ algorithm=algorithm,
+ number_of_chains=3,
+ )
+
+ log_likelihood = LogLikelihood.objects.create(
+ variable=model.variables.first(),
+ inference=inference,
+ form=LogLikelihood.Form.MODEL
+ )
+
+ # remove all outputs except
+ output_names = [
+ 'PDCompartment.TS',
+ ]
+ outputs = []
+ for output in log_likelihood.outputs.all():
+ if output.variable.qname in output_names:
+ output.parent.biomarker_type = bt
+ output.parent.observed = True
+ output.parent.save()
+ outputs.append(output.parent)
+ else:
+ for param in output.parent.parameters.all():
+ if param != output:
+ param.child.delete()
+ output.parent.delete()
+
+ return inference, log_likelihood, bt, bt_covariate, model, dataset
diff --git a/pkpdapp/pkpdapp/urls.py b/pkpdapp/pkpdapp/urls.py
new file mode 100644
index 00000000..fca1f7dc
--- /dev/null
+++ b/pkpdapp/pkpdapp/urls.py
@@ -0,0 +1,90 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+"""
+URL config of the pkpdapp project.
+
+The `urlpatterns` list routes URLs to views. For more information please see
+https://docs.djangoproject.com/en/3.0/topics/http/urls/.
+"""
+
+from django.urls import include, path
+from django.contrib import admin
+from . import api
+from rest_framework import routers
+
+router = routers.DefaultRouter()
+router.register('dataset', api.DatasetView, basename='dataset')
+router.register('user', api.UserView, basename='user')
+router.register('subject', api.SubjectView, basename='subject')
+router.register('compound', api.CompoundView, basename='compound')
+router.register('project', api.ProjectView, basename='project')
+router.register('project_access', api.ProjectAccessView,
+ basename='project_access')
+router.register('dose', api.DoseView, basename='dose')
+router.register('unit', api.UnitView, basename='unit')
+router.register('variable', api.VariableView, basename='variable')
+router.register('protocol', api.ProtocolView, basename='protocol')
+router.register('biomarker_type', api.BiomarkerTypeView,
+ basename='biomarker_type')
+router.register(
+ 'pharmacokinetic', api.PharmacokineticView,
+ basename='pharmacokinetic'
+)
+router.register(
+ 'pharmacodynamic', api.PharmacodynamicView,
+ basename='pharmacodynamic'
+)
+
+router.register(
+ 'combined_model', api.CombinedModelView,
+ basename='combined_model'
+)
+
+router.register(
+ 'inference', api.InferenceView,
+ basename='inference'
+)
+router.register(
+ 'algorithm', api.AlgorithmView,
+ basename='algorithm'
+)
+router.register(
+ 'inference_chain', api.InferenceChainView,
+ basename='inference_chain'
+)
+router.register(
+ 'simulation', api.SimulationViewSet,
+ basename='simulation'
+)
+
+urlpatterns = [
+ path('admin/doc/', include('django.contrib.admindocs.urls')),
+ path('admin/', admin.site.urls),
+ path('accounts/', include('django.contrib.auth.urls')),
+ path('api/', include(router.urls), name='api'),
+ path('api/nca/', api.NcaView.as_view(), name='nca'),
+ path('api/auce/', api.AuceView.as_view(), name='auce'),
+ path('api/combined_model//simulate',
+ api.SimulateCombinedView.as_view(), name='simulate-combined-model'),
+ path(
+ 'api/inference/wizard',
+ api.InferenceWizardView.as_view(),
+ name='inference-wizard'
+ ),
+ path(
+ 'api/inference//stop',
+ api.StopInferenceView.as_view(),
+ name='stop-inference'
+ ),
+ path('api/pharmacodynamic//simulate',
+ api.SimulatePdView.as_view(), name='simulate-pharmacodynamic'),
+ path('api/csrf/', api.get_csrf, name='auth-csrf'),
+ path('api/login/', api.login_view, name='auth-login'),
+ path('api/logout/', api.logout_view, name='auth-logout'),
+ path('api/session/', api.SessionView.as_view(), name='auth-session'),
+ path('api/whoami/', api.WhoAmIView.as_view(), name='auth-whoami'),
+ path('api-auth/', include('rest_framework.urls'))
+]
diff --git a/pkpdapp/pkpdapp/utils/__init__.py b/pkpdapp/pkpdapp/utils/__init__.py
new file mode 100644
index 00000000..f7a84b9d
--- /dev/null
+++ b/pkpdapp/pkpdapp/utils/__init__.py
@@ -0,0 +1,14 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+# flake8: noqa f401
+
+from .nca import NCA
+from .auce import Auce
+from .expression_parser import ExpressionParser
+from .monolix_model_parser import MonolixModelParser
+from .monolix_project_parser import MonolixProjectParser
+from .data_parser import DataParser
+from .monolix_importer import monolix_import
diff --git a/pkpdapp/pkpdapp/utils/auce.py b/pkpdapp/pkpdapp/utils/auce.py
new file mode 100644
index 00000000..acf677f6
--- /dev/null
+++ b/pkpdapp/pkpdapp/utils/auce.py
@@ -0,0 +1,127 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import numpy as np
+from scipy.optimize import curve_fit
+
+
+def fsigmoid(concentration, top, bottom, EC50):
+ """
+ this function simulates Emax-EC50 curve for a
+ given concentration range
+ """
+ return (
+ bottom + concentration *
+ (top - bottom) / (EC50 + concentration)
+ )
+
+
+class Auce():
+ def __init__(
+ self, name, subject_ids, concentrations,
+ subject_times, subject_data
+ ):
+ """
+ Initialise AUCE class for calculating and storing
+ AUCE data and fits
+ :param name: {str} --- group name
+ :param subject_ids: {np.ndarray} --- array of subject ids
+ :param concentrations: {np.ndarray} --- array of concentrations, one
+ for each subject
+ :param subject_times: {list of np.ndarray} --- list of arrays of
+ observation times, one array for each subject
+ :param subject_datas: {list of np.ndarray} --- list of arrays of
+ biomarker values, one array for each subject
+ """
+
+ self.fit_type = 'Sigmoid'
+ self.name = name
+ self.subject_ids = subject_ids
+ self.concentrations = concentrations
+ self.subject_times = subject_times
+ self.subject_data = subject_data
+ self.auce = []
+ for values, times in zip(subject_data, subject_times):
+ self.auce.append(self.calculate_auce(values, times))
+
+ self.x = None
+ self.y = None
+ self.y_upper = None
+ self.y_lower = None
+ self.fit_EC50 = None
+ self.sigma_EC50 = None
+ self.fit_EC50_y = None
+ self.fitted_params = None
+ self.covariates = None
+ self.fit_top = None
+ self.sigma_top = None
+ self.fit_bottom = None
+ self.sigma_bottom = None
+
+ self.auce_fit(
+ self.concentrations, self.auce
+ )
+
+ @staticmethod
+ def calculate_auce(values, times):
+ return np.trapz(values, times)
+
+ def auce_fit(self, concentrations, auce):
+ if self.fit_type != 'Sigmoid':
+ return None
+ if len(concentrations) < 4:
+ return None
+
+ p0 = [max(auce), min(auce), 1000]
+ fitted_params, covariates = curve_fit(
+ fsigmoid, concentrations, auce, p0=p0
+ )
+
+ fit_top, fit_bottom, fit_EC50 = fitted_params
+
+ sigma_top, sigma_bottom, sigma_EC50 = np.sqrt(
+ np.diag(covariates)
+ )
+
+ if (
+ fit_EC50 <= 0 or
+ not sigma_bottom or
+ not sigma_EC50 or
+ not sigma_top or
+ fit_EC50 - abs(sigma_EC50) <= 0
+ ):
+ return None
+
+ if min(concentrations):
+ x = np.geomspace(
+ min(concentrations), max(concentrations), 500
+ )
+ else:
+ x = np.geomspace(0.1, max(concentrations), 500)
+
+ y = fsigmoid(x, *fitted_params)
+
+ y_upper = fsigmoid(
+ x, fit_top + abs(sigma_top),
+ fit_bottom + abs(sigma_bottom),
+ fit_EC50 - abs(sigma_EC50)
+ )
+ y_lower = fsigmoid(
+ x, fit_top - abs(sigma_top),
+ fit_bottom - abs(sigma_bottom),
+ fit_EC50 + abs(sigma_EC50)
+ )
+
+ self.x = x
+ self.y = y
+ self.y_upper = y_upper
+ self.y_lower = y_lower
+ self.fit_EC50 = fit_EC50
+ self.sigma_EC50 = sigma_EC50
+ self.fit_top = fit_top
+ self.sigma_top = sigma_top
+ self.fit_bottom = fit_bottom
+ self.sigma_bottom = sigma_bottom
diff --git a/pkpdapp/pkpdapp/utils/data_parser.py b/pkpdapp/pkpdapp/utils/data_parser.py
new file mode 100644
index 00000000..7e3f751e
--- /dev/null
+++ b/pkpdapp/pkpdapp/utils/data_parser.py
@@ -0,0 +1,264 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import pandas as pd
+from pkpdapp.models import Unit
+from io import StringIO
+
+
+class DataParser:
+ alternate_col_names = {
+ "SUBJECT_ID": [
+ "ID", "id", "Subject_id", "Subject", "SUBJID",
+ "SUBJECT_ID"
+ ],
+ "TIME": [
+ "Time", "TIME", "TIMEPOINT", "t", "T", "time"
+ ],
+ "TIME_UNIT": [
+ "Time_unit", "Time_units", "TIMEUNIT", "TIME_UNIT"
+ ],
+ "AMOUNT": [
+ "Amt", "Amount", "AMT", "AMOUNT"
+ ],
+ "AMOUNT_UNIT": [
+ "Amt_unit", "Amt_units", "AMTUNIT", "UNIT", "AMOUNT_UNIT"
+ ],
+ "OBSERVATION": [
+ "DV", "Observation", "Y", "YVAL", "OBSERVATION",
+ "OBSERVATION_VALUE", "OBSERVATIONVALUE"
+ ],
+ "OBSERVATION_NAME": [
+ "Observation_id", "YDESC", "YNAME", "YTYPE", "OBSERVATION_ID",
+ "OBSERVATION_NAME", "OBSERVATIONID", "OBSERVATIONNAME"
+ ],
+ "OBSERVATION_UNIT": [
+ "DV_units", "Observation_unit", "YUNIT", "UNIT",
+ "OBSERVATION_UNIT",
+ "OBSERVATIONUNIT"
+ ],
+ "COMPOUND": [
+ "Compound", "COMPOUND"
+ ],
+ "ROUTE": [
+ "Route", "ROUTE"
+ ],
+ "INFUSION_TIME": [
+ "TINF", "Tinf", "tinf", "Infusion_time", "INFUSIONTIME",
+ "INFUSION_TIME"
+ ],
+ }
+
+ required_cols = [
+ "SUBJECT_ID",
+ "TIME",
+ "AMOUNT",
+ "OBSERVATION",
+ ]
+
+ optional_cols = [
+ "TIME_UNIT",
+ "AMOUNT_UNIT",
+ "OBSERVATION_UNIT",
+ "OBSERVATION_NAME",
+ "COMPOUND",
+ "ROUTE",
+ "INFUSION_TIME",
+ ]
+
+ altername_unit_names = {
+ "h": ["hour"],
+ "day": ["d"],
+ }
+
+ def is_covariate_column(self, col_name):
+ return col_name not in self.required_cols + self.optional_cols
+
+ def validate(self, data: pd.DataFrame):
+ colnames = data.columns.astype(str).tolist()
+
+ # check that all required columns are present
+ error_cols = []
+ found_cols = {}
+ covariate_cols = {}
+ for col_name in self.required_cols:
+ col_alts = self.alternate_col_names[col_name]
+ found = False
+ for alternate_name in col_alts:
+ if alternate_name in colnames:
+ found_cols[col_name] = alternate_name
+ found = True
+ break
+ if not found:
+ error_cols.append(col_name)
+
+ if len(error_cols) > 0:
+ raise RuntimeError(
+ (
+ 'Error parsing file, '
+ 'does not have the following columns: {}'
+ ).format(error_cols)
+ )
+
+ # search for optional columns
+ for col_name in self.optional_cols:
+ col_alts = self.alternate_col_names[col_name]
+ for alternate_name in col_alts:
+ if alternate_name in colnames:
+ found_cols[col_name] = alternate_name
+ break
+
+ # all remaining columns are covariates
+ for col_name in colnames:
+ if col_name not in found_cols.values():
+ covariate_cols[col_name] = col_name
+
+ # set dataframe column names to standard names
+ # we support the amount unit and observation unit being the same column
+ inv_found_cols = {v: k for k, v in found_cols.items()}
+ if (
+ "AMOUNT_UNIT" in found_cols and
+ "OBSERVATION_UNIT" in found_cols and
+ found_cols["AMOUNT_UNIT"] == found_cols["OBSERVATION_UNIT"]
+ ):
+ amt_obs_unit_same_col = True
+ amt_obs_unit_col = found_cols["AMOUNT_UNIT"]
+
+ # manually set column map and then duplicate column
+ inv_found_cols[amt_obs_unit_col] = "AMOUNT_UNIT"
+ data = data.rename(columns=inv_found_cols)
+ data["OBSERVATION_UNIT"] = data["AMOUNT_UNIT"]
+ else:
+ amt_obs_unit_same_col = False
+ data = data.rename(columns=inv_found_cols)
+
+ # map alternate unit names to standard names
+ inv_altername_unit_names = {}
+ for k, v in self.altername_unit_names.items():
+ for v2 in v:
+ inv_altername_unit_names[v2] = k
+
+ def map_unit_names(x):
+ if x in inv_altername_unit_names:
+ return inv_altername_unit_names[x]
+ else:
+ return x
+ for unit_col in ["TIME_UNIT", "AMOUNT_UNIT", "OBSERVATION_UNIT"]:
+ if unit_col in found_cols:
+ data[unit_col] = data[unit_col].map(map_unit_names)
+
+ # put in default observation name if not present
+ if "OBSERVATION_NAME" not in found_cols:
+ data["OBSERVATION_NAME"] = "observation"
+
+ # put in default compound name if not present
+ if "COMPOUND" not in found_cols:
+ data["COMPOUND"] = "unknown compound"
+
+ # put in default route name if not present
+ if "ROUTE" not in found_cols:
+ data["ROUTE"] = "IV"
+
+ # put in default units if not present, convert any percentage units
+ # to dimensionless
+ for unit_col in ["TIME_UNIT", "AMOUNT_UNIT", "OBSERVATION_UNIT"]:
+ if unit_col not in found_cols:
+ data[unit_col] = ""
+ else:
+ def convert_percent_to_dim(x):
+ xl = x.lower()
+ if (
+ "percent" in xl or
+ "fraction" in xl or
+ "ratio" in xl or
+ "%" in xl
+ ):
+ return ""
+ else:
+ return x
+ data[unit_col] = data[unit_col].map(convert_percent_to_dim)
+
+ # put in default infusion time if not present
+ delta_time = data.sort_values(by=["TIME"]).groupby(
+ ["SUBJECT_ID"]
+ )["TIME"].diff().dropna()
+ min_delta_time = delta_time[delta_time > 0].min()
+ if "INFUSION_TIME" not in found_cols:
+ data["INFUSION_TIME"] = min_delta_time / 100.0
+
+ # check that infusion time is not zero or negative
+ if (
+ data["INFUSION_TIME"].apply(pd.to_numeric, errors='coerce') <= 0
+ ).any():
+ raise RuntimeError(
+ (
+ 'Error parsing file, '
+ 'contains zero infusion time'
+ )
+ )
+
+ # check that units are in database
+ for unit_col in ["TIME_UNIT", "AMOUNT_UNIT", "OBSERVATION_UNIT"]:
+ if unit_col in found_cols:
+ units = data[unit_col].unique().tolist()
+ pkpdapp_units = Unit.objects.all()
+ pkpdapp_units_symbols = \
+ pkpdapp_units.values_list('symbol', flat=True)
+ error_units = set([
+ u for u in units
+ if u not in pkpdapp_units_symbols
+ ])
+ if len(error_units) > 0:
+ raise RuntimeError(
+ (
+ 'Error parsing file, '
+ 'contains the following unknown units: {}'
+ ).format(error_units)
+ )
+
+ # check that time unit is constant
+ if "TIME_UNIT" in found_cols:
+ time_units = data["TIME_UNIT"].unique()
+ if len(time_units) > 1:
+ raise RuntimeError(
+ (
+ 'Error parsing file, '
+ 'contains multiple time units: {}'
+ ).format(time_units)
+ )
+
+ # check that units are same for each observation type
+ if "OBSERVATION_UNIT" in found_cols:
+ obs_units = data.groupby("OBSERVATION_NAME")[
+ "OBSERVATION_UNIT"].unique()
+ if amt_obs_unit_same_col:
+ max_num_units = 2
+ else:
+ max_num_units = 1
+ if obs_units.apply(lambda x: len(x) > max_num_units).any():
+ raise RuntimeError(
+ (
+ 'Error parsing file, '
+ 'contains multiple observation units: {}'
+ ).format(obs_units)
+ )
+
+ # check for missing data and drop any rows where data are missing
+ num_missing = data.isna().sum().sum()
+ if num_missing > 0:
+ data = data.fillna('')
+ return data
+
+ def parse_from_str(self, data_str, delimiter=None):
+ data = StringIO(data_str)
+ data = pd.read_csv(data, delimiter=delimiter)
+ data = self.validate(data)
+ return data
+
+ def parse_from_stream(self, data_stream, delimiter=None):
+ data = pd.read_csv(data_stream, delimiter=delimiter)
+ data = self.validate(data)
+ return data
diff --git a/pkpdapp/pkpdapp/utils/default_params.py b/pkpdapp/pkpdapp/utils/default_params.py
new file mode 100644
index 00000000..614e5aa7
--- /dev/null
+++ b/pkpdapp/pkpdapp/utils/default_params.py
@@ -0,0 +1,53 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import openpyxl
+
+
+# Load the workbook
+workbook = openpyxl.load_workbook(
+ "pkpdapp/migrations/models/ParametersValue_Species.xlsx", data_only=True
+)
+
+sheet_names = [
+ "1cmpt_PK_Model",
+ "2cmpt_PK_Model",
+ "3cmpt_PK_Model",
+ "1cmpt_TMDD_Model",
+ "2cmpt_TMDD_Model",
+]
+model_names = [
+ "one_compartment",
+ "two_compartment",
+ "three_compartment",
+ "one_compartment_tmdd",
+ "two_compartment_tmdd",
+]
+species_list = ["M", "R", "K", "H"]
+compound_type = ["SM", "LM"]
+clinical = [False, False, False, True]
+
+defaults = {}
+
+for sheet_name, model_name in zip(sheet_names, model_names):
+ worksheet = workbook[sheet_name]
+
+ defaults[model_name] = {}
+ for row in worksheet.iter_rows():
+ parameter = row[0].value
+ if parameter is None:
+ continue
+ defaults[model_name][parameter] = {}
+ for i, species in enumerate(species_list):
+ defaults[model_name][parameter][species] = {}
+ for j, ctype in enumerate(compound_type):
+ rowi = i * 4 + j * 2 + 1
+ value = row[rowi].value
+ unit = row[rowi + 1].value
+ if_clinical = clinical[i]
+ defaults[model_name][parameter][species][ctype] = {
+ "value": value,
+ "unit": unit,
+ }
diff --git a/pkpdapp/pkpdapp/utils/expression_parser.py b/pkpdapp/pkpdapp/utils/expression_parser.py
new file mode 100644
index 00000000..8284d14d
--- /dev/null
+++ b/pkpdapp/pkpdapp/utils/expression_parser.py
@@ -0,0 +1,163 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+# based on fourFn.py example from pyparsing
+# (https://github.com/pyparsing/pyparsing/blob/master/examples/fourFn.py)
+# Copyright 2003-2019 by Paul McGuire
+#
+import math
+import operator
+from pyparsing import (
+ Literal,
+ Word,
+ Group,
+ Forward,
+ alphas,
+ alphanums,
+ Regex,
+ ParseException,
+ dbl_quoted_string,
+ sgl_quoted_string,
+ remove_quotes,
+ Suppress,
+ Keyword,
+ delimitedList,
+)
+
+epsilon = 1e-12
+opn = {
+ "+": operator.add,
+ "-": operator.sub,
+ "*": operator.mul,
+ "/": operator.truediv,
+ "^": operator.pow,
+}
+
+functions = {
+ "sin": math.sin,
+ "cos": math.cos,
+ "tan": math.tan,
+ "exp": math.exp,
+ "abs": abs,
+ "trunc": int,
+ "round": round,
+ "sgn": lambda a: -1 if a < -epsilon else 1 if a > epsilon else 0,
+ # functionsl with multiple arguments
+ "multiply": lambda a, b: a * b,
+ "hypot": math.hypot,
+ # functions with a variable number of arguments
+ "all": lambda *a: all(a),
+}
+
+
+class ExpressionParser:
+ """
+ expop :: '^'
+ multop :: '*' | '/'
+ addop :: '+' | '-'
+ integer :: ['+' | '-'] '0'..'9'+
+ atom :: real | Parameter '[' string ']'
+ | Biomarker '[' string ']'
+ | fn '(' expr ')'
+ | '(' expr ')'
+ factor :: atom [ expop factor ]*
+ term :: factor [ multop factor ]*
+ expr :: term [ addop term ]*
+ """
+ # map operator symbols to corresponding arithmetic operations
+
+ def __init__(self):
+ # use CaselessKeyword for e and pi, to avoid accidentally matching
+ # functions that start with 'e' or 'pi' (such as 'exp'); Keyword
+ # and CaselessKeyword only match whole words
+ param = Keyword("parameter")
+ biomarker = Keyword("biomarker")
+ string = (dbl_quoted_string | sgl_quoted_string).setParseAction(
+ remove_quotes, self.push_first
+ )
+ # fnumber = Combine(Word("+-"+nums, nums) +
+ # Optional("." + Optional(Word(nums))) +
+ # Optional(e + Word("+-"+nums, nums)))
+ # or use provided pyparsing_common.number, but convert back to str:
+ # fnumber = ppc.number().addParseAction(lambda t: str(t[0]))
+ fnumber = Regex(r"[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?")
+ ident = Word(alphas, alphanums + "_$")
+
+ plus, minus, mult, div = map(Literal, "+-*/")
+ lpar, rpar = map(Suppress, "()")
+ addop = plus | minus
+ multop = mult | div
+ expop = Literal("^")
+
+ expr = Forward()
+ expr_list = delimitedList(Group(expr))
+
+ # add parse action that replaces the function identifier with a (name,
+ # number of args) tuple
+ def insert_fn_argcount_tuple(t):
+ fn = t.pop(0)
+ num_args = len(t[0])
+ t.insert(0, (fn, num_args))
+
+ fn_call = (ident + lpar - Group(expr_list) + rpar).setParseAction(
+ insert_fn_argcount_tuple
+ )
+ atom = (
+ addop[...] +
+ (
+ (
+ param + lpar + string + rpar
+ ).setParseAction(self.push_first) |
+ (
+ biomarker + lpar + string + rpar
+ ).setParseAction(self.push_first) |
+ (
+ fn_call | fnumber | ident
+ ).setParseAction(self.push_first) |
+ Group(lpar + expr + rpar)
+ )
+ ).setParseAction(self.push_unary_minus)
+
+ # by defining exponentiation as "atom [ ^ factor ]..." instead of "atom
+ # [ ^ atom ]...", we get right-to-left exponents, instead of
+ # left-to-right that is, 2^3^2 = 2^(3^2), not (2^3)^2.
+ factor = Forward()
+ factor <<= atom + (expop + factor).setParseAction(self.push_first)[...]
+ term = factor + (multop + factor).setParseAction(self.push_first)[...]
+ expr <<= term + (addop + term).setParseAction(self.push_first)[...]
+
+ self.exprStack = []
+ self.bnf = expr
+
+ def push_first(self, toks):
+ self.exprStack.append(toks[0])
+
+ def push_unary_minus(self, toks):
+ for t in toks:
+ if t == "-":
+ self.exprStack.append("unary -")
+ else:
+ break
+
+ def parse(self, string, parseAll=True):
+ self.exprStack[:] = []
+ self.bnf.parseString(string, parseAll=parseAll)
+
+ def is_valid(self, string):
+ try:
+ self.parse(string)
+ return True
+ except ParseException:
+ return False
+
+ def get_params(self, string, parseAll=True):
+ self.exprStack[:] = []
+ self.bnf.parseString(string, parseAll=parseAll)
+ ret = []
+ for i, op in enumerate(self.exprStack):
+ if op == 'parameter' or op == 'biomarker':
+ ret.append((op, self.exprStack[i - 1]))
+ return list(set(ret))
diff --git a/pkpdapp/pkpdapp/utils/monolix_importer.py b/pkpdapp/pkpdapp/utils/monolix_importer.py
new file mode 100644
index 00000000..17350501
--- /dev/null
+++ b/pkpdapp/pkpdapp/utils/monolix_importer.py
@@ -0,0 +1,133 @@
+
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+from django.apps import apps
+
+from pkpdapp.models import (
+ Project
+)
+from pkpdapp.utils import (
+ MonolixModelParser,
+ MonolixProjectParser,
+ DataParser
+)
+
+
+def monolix_import(
+ app_project: Project, project_str: str,
+ model_str: str, data_str: str, validate: bool = True
+):
+ """
+ Import a Monolix project into the database.
+
+ Parameters
+ ----------
+ project
+ project file as a string
+ model
+ model file as a string
+ data
+ data file as a string
+ """
+
+ # parse the project file
+ project_parser = MonolixProjectParser()
+ project = project_parser.parse(project_str)
+
+ # parse the model file
+ model_parser = MonolixModelParser()
+ model, (admin_id, dosed_compartment, tlag,
+ direct, dosed_qname) = model_parser.parse(model_str)
+
+ # parse the data file
+ data_parser = DataParser()
+ delimiter = project['']['[FILEINFO]']['delimiter']
+ if delimiter == 'tab':
+ delimiter = '\t'
+ data = data_parser.parse_from_str(data_str, delimiter=delimiter)
+
+ if validate:
+ return
+
+ # set the parameters of the myokit model to match the typical population
+ # parameters
+ for parameter_name, parameter in project[
+ ''
+ ]['[INDIVIDUAL]']['DEFINITION:'].items():
+ typical_str = parameter['typical']
+ try:
+ typical_value = float(typical_str)
+ except ValueError:
+ # must refer to a population parameter
+ population_parameter = project[''][typical_str]
+ typical_value = population_parameter['value']
+ var = model.var('root.{}'.format(parameter_name))
+ var.set_rhs(typical_value)
+
+ # create the pd model
+ PharmacodynamicModel = apps.get_model('pkpdapp', 'PharmacodynamicModel')
+ pd_model = PharmacodynamicModel.objects.create(
+ name=project['']['[LONGITUDINAL]']['file'],
+ project=app_project,
+ mmt=model.code(),
+ )
+
+ # create the dataset
+ Dataset = apps.get_model('pkpdapp', 'Dataset')
+ dataset = Dataset.objects.create(
+ name=project['']['[FILEINFO]']['file'],
+ project=app_project,
+ )
+
+ # only display the fitted output of dataset
+ for bt in dataset.biomarker_types.all():
+ if bt.name == project['']['data']:
+ bt.display = True
+ else:
+ bt.display = False
+ bt.save()
+
+ if direct:
+ data.assign(ROUTE='IV')
+ else:
+ data.assign(ROUTE='Extravascular')
+
+ dataset.replace_data(data)
+
+ # get the right protocol
+ # (TODO: we cheat and only get the one for the first subject)
+ protocol = dataset.subjects.first().protocol
+
+ # create the pk model
+ CombinedModel = apps.get_model(
+ 'pkpdapp', 'CombinedModel')
+ pk_model = CombinedModel.objects.create(
+ name='Dosed {}'.format(project['']['[LONGITUDINAL]']['file']),
+ project=app_project,
+ pd_model=pd_model,
+ pk_model=None,
+ )
+
+ drug = pk_model.variables.get(qname=dosed_qname)
+ drug.protocol = protocol
+ drug.save()
+
+ # only display the fitted output of model
+ fit_variable = project['']['model']
+ model_variable = project[
+ ''
+ ][
+ '[LONGITUDINAL]'
+ ][
+ 'DEFINITION:'
+ ][fit_variable]['prediction']
+ for model in [pd_model, pk_model]:
+ for var in model.variables.filter(constant=False):
+ var.display = var.name == model_variable
+ var.save()
+
+ return pd_model, pk_model, dataset
diff --git a/pkpdapp/pkpdapp/utils/monolix_model_parser.py b/pkpdapp/pkpdapp/utils/monolix_model_parser.py
new file mode 100644
index 00000000..d3729058
--- /dev/null
+++ b/pkpdapp/pkpdapp/utils/monolix_model_parser.py
@@ -0,0 +1,329 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+# based on fourFn.py example from pyparsing
+# (https://github.com/pyparsing/pyparsing/blob/master/examples/fourFn.py)
+# Copyright 2003-2019 by Paul McGuire
+#
+from dataclasses import dataclass
+
+import myokit
+import numbers
+import pyparsing as pp
+import pyparsing.common as ppc
+
+pp.enable_all_warnings()
+
+binops = {
+ '/': myokit.Divide,
+ '*': myokit.Multiply,
+ '-': myokit.Minus,
+ '+': myokit.Plus,
+}
+
+
+@dataclass
+class Variable:
+ name: str
+ constant: bool
+ state: bool
+
+
+class MonolixModelParser:
+ """
+ expop :: '^'
+ multop :: '*' | '/'
+ addop :: '+' | '-'
+ integer :: ['+' | '-'] '0'..'9'+
+ atom :: real
+ | ident
+ | '(' expr ')'
+ factor :: atom [ expop factor ]*
+ term :: factor [ multop factor ]*
+ expr :: term [ addop term ]*
+ eqn :: term
+ """
+ # map operator symbols to corresponding arithmetic operations
+
+ def __init__(self):
+ # fnumber = Combine(Word("+-"+nums, nums) +
+ # Optional("." + Optional(Word(nums))) +
+ # Optional(e + Word("+-"+nums, nums)))
+ # or use provided pyparsing_common.number, but convert back to str:
+ fnumber = ppc.number()
+ ident = pp.Regex("[_a-zA-Z][_a-zA-Z0-9]*")
+ ident_0 = pp.Regex("[_a-zA-Z][_a-zA-Z0-9]*_0")
+ ddt_ident = pp.Regex("ddt_[_a-zA-Z][_a-zA-Z0-9]*")
+
+ plus, minus, mult, div = map(pp.Literal, "+-*/")
+ lpar, rpar = map(pp.Suppress, "()")
+ lcpar, rcpar = map(pp.Suppress, "{}")
+ addop = plus | minus
+ multop = mult | div
+ expop = pp.Literal("^")
+ equals = pp.Suppress("=")
+
+ expr = pp.Forward()
+ atom = (
+ addop[...] + (
+ (fnumber | ident).set_parse_action(self.push_first) |
+ pp.Group(lpar + expr + rpar)
+ )
+ ).set_parse_action(self.push_unary_minus)
+
+ # by defining exponentiation as "atom [ ^ factor ]..." instead of "atom
+ # [ ^ atom ]...", we get right-to-left exponents, instead of
+ # left-to-right that is, 2^3^2 = 2^(3^2), not (2^3)^2.
+ factor = pp.Forward()
+ factor <<= (
+ atom +
+ (expop + factor).set_parse_action(self.push_first)[...]
+ )
+ term = (
+ factor +
+ (multop + factor).set_parse_action(self.push_first)[...]
+ )
+ expr <<= (
+ term +
+ (addop + term).set_parse_action(self.push_first)[...]
+ )
+
+ ode_type = pp.Keyword('odeType') + equals + (pp.Keyword('stiff') |
+ pp.Keyword('nonStiff'))
+ equation = (
+ ident + equals +
+ pp.Group(expr).set_parse_action(self.construct_expr)
+ )
+ initial_condition = (
+ ident_0 + equals +
+ pp.Group(expr).set_parse_action(self.construct_expr)
+ )
+ rate_equation = (
+ ddt_ident + equals +
+ pp.Group(expr).set_parse_action(self.construct_expr)
+ )
+
+ fn_value = fnumber | ident
+ fn_arg = (ident + equals + fn_value) | fn_value
+ fn_call = (
+ ident + lpar -
+ pp.delimited_list(pp.Group(fn_arg), delim=',') + rpar
+ )
+
+ pk_block = ("PK:" + (
+ pp.Group(fn_call)
+ )[...]).set_parse_action(self.construct_pk)
+
+ equation_block = pp.Keyword("EQUATION:") + (
+ ode_type |
+ rate_equation.set_parse_action(
+ self.construct_rate_equation
+ ) |
+ initial_condition.set_parse_action(
+ self.construct_initial_condition
+ ) |
+ equation.set_parse_action(
+ self.construct_equation
+ )
+
+ )[...]
+
+ output_block = pp.Keyword("OUTPUT:") + (
+ ident + equals +
+ lcpar - pp.delimited_list(ident, delim=',') +
+ rcpar
+ )
+
+ inputs = (
+ pp.Keyword("input") + equals + lcpar -
+ pp.delimited_list(
+ ident, delim=','
+ ).set_parse_action(self.construct_inputs) +
+ rcpar
+ )
+
+ longitudinal_keyword = pp.Keyword("[LONGITUDINAL]")
+
+ longitudinal = (
+ longitudinal_keyword +
+ inputs +
+ (
+ pk_block & equation_block & output_block
+ )
+ )
+
+ src = "DESCRIPTION:" + pp.SkipTo(longitudinal_keyword) + longitudinal
+
+ monolix_comment = ';' + pp.restOfLine()
+ src.ignore(monolix_comment)
+
+ pp.autoname_elements()
+ self.parser = src
+ self.exprStack = []
+ self.variables = {}
+ self.pk = []
+ self.myokit_model: myokit.Model = myokit.Model()
+ self.units = {}
+ self.administration_id = None
+ self.tlag = None
+ self.direct_dosing = None
+ self.dosed_compartment = None
+ self.dosed_qname = None
+
+ def initialise_model(self):
+ self.myokit_model: myokit.Model = myokit.Model()
+ root_cmp = self.myokit_model.add_component('root')
+ t = self.get_or_construct_var('t', root_cmp)
+ t.set_binding('time')
+
+ def push_first(self, toks):
+ self.exprStack.append(toks[0])
+
+ def push_unary_minus(self, toks):
+ for t in toks:
+ if t == "-":
+ self.exprStack.append("unary -")
+ else:
+ break
+
+ def construct_pk(self, toks):
+ compartments = {}
+ for line in toks[1:]:
+ fn_name, *tok_args = line
+ args = {}
+ for i, arg in enumerate(tok_args):
+ if len(arg) == 2:
+ [name, value] = arg
+ args[name] = value
+ else:
+ [value] = arg
+ args[i] = value
+
+ if fn_name == 'compartment':
+ cmt = args.get('cmt', args.get(0, 1))
+ if not isinstance(cmt, str) or cmt[0].isalpha():
+ cmt = f'cmt{cmt}'
+ amount = args.get('amount', args.get(1, None))
+ volume = args.get('volume', args.get(2, 1))
+ concentration = args.get('concentration', args.get(3, None))
+ comp = self.myokit_model.add_component(cmt)
+ if isinstance(volume, str):
+ volume_var = self.get_or_construct_var(volume, comp)
+ else:
+ volume_var = myokit.Number(volume)
+ if amount:
+ amount_var = self.get_or_construct_var(amount, comp)
+ else:
+ raise pp.ParseException(
+ f'arg "amount" required for compartment {cmt}')
+ if concentration:
+ conc_var = self.get_or_construct_var(concentration, comp)
+ conc_var.set_rhs(myokit.Divide(amount_var, volume_var))
+ compartments[cmt] = amount_var
+
+ elif fn_name == 'iv':
+ cmt = args.get('cmt', args.get(0, 1))
+ if not isinstance(cmt, str) or cmt[0].isalpha():
+ cmt = f'cmt{cmt}'
+ adm = args.get('adm', args.get(1, 1))
+ if self.administration_id is not None:
+ raise pp.ParseException(
+ 'only a single administration id supported'
+ )
+ self.administration_id = str(adm)
+ tlag = args.get('Tlag', args.get(2, 0))
+ self.tlag = float(tlag)
+ # p = args.get('p', args.get(3, 1))
+
+ if cmt not in compartments:
+ raise pp.ParseException(
+ f'compartment {cmt} not found in pk block'
+ )
+ amount_var = compartments[cmt]
+ if not amount_var.is_state():
+ amount_var.promote(0)
+ direct = True
+ self.direct_dosing = direct
+ self.dosed_compartment = cmt
+ self.dosed_qname = amount_var.qname()
+
+ def construct_inputs(self, toks):
+ for name in toks:
+ _ = self.get_or_construct_var(name)
+
+ def construct_expr(self, toks):
+ toks[0] = self.construct_myokit_expr(self.exprStack)
+
+ def get_or_construct_var(self, name, compartment=None):
+ if compartment is None:
+ compartment = self.myokit_model.get('root')
+ if name not in self.variables:
+ var = compartment.add_variable(name)
+ var.set_rhs(0)
+ if name in self.units:
+ unit = myokit.Unit.parse_simple(self.units[name])
+ else:
+ unit = None
+ var.set_unit(unit)
+ self.variables[name] = var
+ return self.variables[name]
+
+ def construct_equation(self, toks):
+ name, expr = toks
+ var = self.get_or_construct_var(name)
+ var.set_rhs(expr)
+
+ def construct_rate_equation(self, toks):
+ name, expr = toks
+ # get rid of ddt_
+ name = name[4:]
+ var = self.get_or_construct_var(name)
+ if not var.is_state():
+ var.promote(0)
+ var.set_rhs(expr)
+
+ def construct_initial_condition(self, toks):
+ name, expr = toks
+ # get rid of _0
+ name = name[:-2]
+ var = self.get_or_construct_var(name)
+
+ if var == self.myokit_model.time():
+ var.set_rhs(expr)
+ elif var.is_state():
+ var.demote()
+ var.promote(expr)
+ else:
+ var.promote(expr)
+
+ def construct_myokit_expr(self, s):
+ op = s.pop()
+ if isinstance(op, numbers.Number):
+ return myokit.Number(op)
+ if op == "unary -":
+ return myokit.PrefixMinus(self.construct_myokit_expr(s))
+ if op in "+-*/^":
+ # note: operands are pushed onto the stack in reverse order
+ op2 = self.construct_myokit_expr(s)
+ op1 = self.construct_myokit_expr(s)
+ return binops[op](op1, op2)
+ elif op[0].isalpha():
+ var = self.get_or_construct_var(op)
+ return myokit.Name(var)
+ else:
+ raise pp.ParseException(f'unknown op {op}')
+
+ def parse(self, model_str, parseAll=True):
+ try:
+ self.initialise_model()
+ self.parser.parseString(model_str, parseAll=parseAll)
+ except pp.ParseException as err:
+ raise RuntimeError(err.explain())
+ return self.myokit_model, \
+ (
+ self.administration_id, self.dosed_compartment,
+ self.tlag, self.direct_dosing, self.dosed_qname
+ )
diff --git a/pkpdapp/pkpdapp/utils/monolix_project_parser.py b/pkpdapp/pkpdapp/utils/monolix_project_parser.py
new file mode 100644
index 00000000..9244d3b6
--- /dev/null
+++ b/pkpdapp/pkpdapp/utils/monolix_project_parser.py
@@ -0,0 +1,121 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+# based on fourFn.py example from pyparsing
+# (https://github.com/pyparsing/pyparsing/blob/master/examples/fourFn.py)
+# Copyright 2003-2019 by Paul McGuire
+#
+import pyparsing as pp
+import pyparsing.common as ppc
+
+pp.enable_all_warnings()
+
+
+class MonolixProjectParser:
+ def __init__(self):
+ fnumber = ppc.number()
+ ident = pp.Regex("[_a-zA-Z][-_a-zA-Z0-9]*")
+
+ lpar, rpar = map(pp.Suppress, "()")
+ lcpar, rcpar = map(pp.Suppress, "{}")
+ equals = pp.Suppress("=")
+
+ array = pp.Forward()
+ func_arg = ident
+ func = (
+ ident + lpar -
+ pp.delimited_list(pp.Group(func_arg), delim=',') + rpar
+ )
+ array_or_ident_or_number_or_func = (func | ident | fnumber | array)
+ array_entry = (ident + equals +
+ array_or_ident_or_number_or_func) | ident | fnumber
+ array <<= (
+ lcpar +
+ pp.delimited_list(pp.Group(array_entry), delim=',') +
+ rcpar
+ ).set_parse_action(self.parse_array)
+ entry_value = ident | pp.QuotedString("'") | array
+ entry = (ident + equals + entry_value)
+
+ entry_list = pp.ZeroOrMore(entry).set_parse_action(
+ self.parse_list_of_key_values)
+ definition_block = pp.Keyword("DEFINITION:") + entry_list
+ file_info = pp.Keyword("[FILEINFO]") + entry_list
+ file_content = pp.Keyword("[CONTENT]") + entry_list
+ data = (
+ pp.Keyword("") + (
+ file_info + file_content
+ ).set_parse_action(self.parse_list_of_key_values)
+ )
+ covariate = pp.Keyword("[COVARIATE]") + (
+ entry_list + pp.Opt(definition_block)
+ ).set_parse_action(self.parse_add_list_of_key_values)
+ individual = pp.Keyword("[INDIVIDUAL]") + (
+ entry_list + pp.Opt(definition_block)
+ ).set_parse_action(self.parse_add_list_of_key_values)
+ longitudinal = pp.Keyword("[LONGITUDINAL]") + (
+ entry_list + pp.Opt(definition_block)
+ ).set_parse_action(self.parse_add_list_of_key_values)
+ model = pp.Keyword("") + (
+ covariate + individual + longitudinal
+ ).set_parse_action(self.parse_list_of_key_values)
+
+ task_arg = (ident + equals + array_or_ident_or_number_or_func)
+ task = (
+ ident + lpar -
+ pp.Opt(pp.delimited_list(pp.Group(task_arg), delim=',')) + rpar
+ )
+ task_list = pp.ZeroOrMore(task).set_parse_action(
+ self.parse_list_of_key_values)
+ tasks = pp.Keyword("[TASKS]") + task_list
+
+ ident_or_string_or_number = ident | fnumber | pp.QuotedString("'")
+ key_value = ident + equals + ident_or_string_or_number
+ key_value_list = pp.ZeroOrMore(key_value).set_parse_action(
+ self.parse_list_of_key_values)
+ global_settings = pp.Keyword("GLOBAL:") + key_value_list
+ population_settings = pp.Keyword("POPULATION:") + key_value_list
+ settings = pp.Keyword("[SETTINGS]") + (
+ pp.Opt(global_settings) + pp.Opt(population_settings)
+ ).set_parse_action(self.parse_list_of_key_values)
+ monolix = pp.Keyword(
+ "") + (
+ tasks + settings
+ ).set_parse_action(self.parse_list_of_key_values)
+
+ fit = pp.Keyword("") + entry_list
+ parameter = pp.Keyword("") + entry_list
+ src = (data + model + fit + parameter +
+ monolix).set_parse_action(self.parse_list_of_key_values)
+
+ monolix_comment = ';' + pp.restOfLine()
+ src.ignore(monolix_comment)
+
+ pp.autoname_elements()
+ self.parser = src
+
+ def parse_array(self, s: str, loc: int, toks):
+ # if all elements are singletons, return a list of the elements
+ if all([len(x) == 1 for x in toks]):
+ return [[x[0] for x in toks]]
+ # if all elements are tuples, return a dict of the elements
+ return [{x[0]: x[1] if len(x) > 1 else True for x in toks}]
+
+ def parse_list_of_key_values(self, toks):
+ return [{toks[2 * i]: toks[2 * i + 1] for i in range(len(toks) // 2)}]
+
+ def parse_add_list_of_key_values(self, toks):
+ return [
+ toks[0] | {toks[2 * i + 1]: toks[2 * i + 2]
+ for i in range((len(toks) - 1) // 2)}
+ ]
+
+ def parse(self, project_str, parseAll=True) -> dict:
+ try:
+ result = self.parser.parseString(project_str, parseAll=parseAll)
+ except pp.ParseException as err:
+ raise RuntimeError(err.explain())
+ return result.asList()[0]
diff --git a/pkpdapp/pkpdapp/utils/nca.py b/pkpdapp/pkpdapp/utils/nca.py
new file mode 100644
index 00000000..b1f067d4
--- /dev/null
+++ b/pkpdapp/pkpdapp/utils/nca.py
@@ -0,0 +1,294 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import numpy as np
+import scipy.stats as stats
+
+
+class NCA():
+ def __init__(self,
+ times, concs, DM,
+ doseSchedule='Single', administrationRoute='IVBolus'
+ ):
+ """
+ Initialise NCA class for calculating and storing NCA parameters
+ :param times: {np.ndarray} --- array of observation times
+ :param concs: {np.ndarray} --- array of observed concentration values
+ :param DM: {float} --- administered dose amount
+ :param doseSchedule: {string} Single or Multiple dose data
+ :param administrationRoute: {string} IVBolus, IVInfusion, ExtraVascular
+ """
+ # Check if intial concentration has been measured
+
+ if times[0] == 0:
+ self.is_c0extrapolated = False # initial concentration measured
+ self.times = times
+ self.concentrations = concs
+ self.dose_amount = DM # dose amount
+ self.c_0 = None # not extrapolated
+ self.administration_route = administrationRoute
+ else:
+ self.is_c0extrapolated = True # initial concentration NOT measured
+ c0 = self.extrapolate_c0(concs, times) # extrapolate initial conc
+ self.c_0 = c0
+ self.times = np.insert(times, 0, 0, axis=0)
+ self.concentrations = np.insert(concs, 0, c0, axis=0)
+ self.dose_amount = DM # dose amount
+ self.administration_route = administrationRoute
+
+ def calculate_nca(self):
+ """
+ Calculates and stores all single dose NCA parameters
+ :return: None
+ """
+ self.auc_0_last = self._auc_0_last()
+ self.aumc_0_last = self._aumc_0_last()
+ self.lambda_z, self.r2, self.num_points = self._Lambda_z()
+
+ self.auc_infinity = self._auc_infinity()
+ self.auc_infinity_dose = self._auc_infinity_dose()
+ # self.aucx_y
+ self.auc_extrap_percent = self._auc_extrap_percent()
+ self.cl = self._CL()
+ self.c_max, self.t_max = self._find_Cmax()
+ self.c_max_dose = self._C_max_Dose()
+ # C_max_x_y
+
+ self.aumc = self._aumc()
+ self.aumc_extrap_percent = self._aumc_extrap_percent()
+ self.mrt = self._MRT()
+ self.tlast = self._Tlast() # ?? above LOQ?
+ self.t_half = np.log(2) / self.lambda_z
+ # T_max_x_y
+ if self.administration_route == 'IVBolus':
+ self.v_ss = self._V_ss()
+ else:
+ self.v_ss = None
+
+ self.v_z = self._V_z()
+
+ @staticmethod
+ def extrapolate_c0(y, x):
+ """
+ Calculate initial concentration when not given, computed using a (log)
+ regression of the first two data points in a profile.
+ Arguments:
+ y {np.ndarray} -- y coordinates of points on curve
+ x {np.ndarray} -- x coordinates of points on curve
+
+ Returns:
+ c0 {double} -- extrapoloated c0
+ """
+ _, intercept, _, _, _ = \
+ stats.linregress(x[:2], np.log(y[:2]), )
+ c0 = np.exp(intercept)
+ return c0
+
+ @staticmethod
+ def log_trapz(y, x):
+ """Calculate area under curve using log trapezoidal method (log mean).
+ Arguments:
+ :param y {np.ndarray} -- y coordinates of points on curve
+ :param x {np.ndarray} -- x coordinates of points on curve
+ Returns:
+ :return area {double} -- area under curve
+ """
+ y1 = y[:-1]
+ x1 = x[:-1]
+ y2 = y[1:]
+ x2 = x[1:]
+
+ area = np.sum((y1 - y2) / (np.log(y1) - np.log(y2)) * (x2 - x1))
+ return area
+
+ @staticmethod
+ def linlog_trapz(y, x, linlog=True):
+ """
+ Calculate area under curve using combination of linear and log
+ trapezoidal method (linear when increasing, log when decreasing) or
+ optionally just linear trapezoidal method
+ :param y {np.ndarray} -- y coordinates of points on curve
+ :param x {np.ndarray} -- x coordinates of points on curve
+ :param linlog {bool} -- use linear-log trapezoidal method
+ Returns:
+ :return area {float} -- area under curve
+ """
+ if linlog: # use lin-log trapezoid
+ ymax_indx = np.argmax(y) # index of maximum concentration
+ # linear trapezium for increasing part
+ area1 = np.trapz(y[:ymax_indx + 1], x[:ymax_indx + 1])
+ # log trapezium for decreasing part
+ area2 = NCA.log_trapz(y[ymax_indx:], x[ymax_indx:])
+ area = area1 + area2
+ else: # use linear trapezoid only
+ area = np.trapz(x, y)
+ return area
+
+ def _auc_0_last(self, linlog=True):
+ """
+ Calculates area under the concentration–time curve (auc) from time 0 to
+ the last time point Tlast using linear-log trapezoidal method
+ Arguments:
+ :param y {np.ndarray} -- y coordinates of points on curve
+ :param x {np.ndarray} -- x coordinates of points on curve
+ Returns:
+ :return auc {float} -- aumc
+ """
+ y = self.concentrations
+ x = self.times
+ auc = self.linlog_trapz(y, x, linlog=linlog)
+ return auc
+
+ def _aumc_0_last(self, linlog=True):
+ """
+ Calculate area under the first moment of the concentration–time curve
+ (aumc) from time 0 to the last time point Tlast using linear log
+ trapezoidal method
+ Arguments:
+ :param y {np.ndarray} -- y coordinates of points on curve
+ :param x {np.ndarray} -- x coordinates of points on curve
+ Returns:
+ :return aumc {float} -- aumc
+ """
+ # conc * time for first moment curve
+ y = self.concentrations * self.times
+ x = self.times
+ aumc = self.linlog_trapz(y, x, linlog=linlog)
+ return aumc
+
+ def _Lambda_z(self):
+ """
+ Calculates terminal rate constant by performing set of linear
+ regressions on log(conc)-time data using the last n (=3,4,...) points
+ from the terminal (decreasing T >= Tmax) section of curve and returning
+ rate constant with maximum adj_r
+ :return lambda_z {float} -- terminal rate constant
+ :return R2 {float} -- coefficient of determination for best
+ linear regression
+ :return m {int} -- number of data points used in best linear regression
+ """
+ y = self.concentrations
+ x = self.times
+ r = 0
+ lambda_z = 0
+ cmax_indx = np.argmax(y) # index of max concentration
+ n_upper = len(y) - cmax_indx # max number of points to consider
+ for n in range(3, n_upper + 1): # perform regressions
+ slope, intercept, r_value, _, _ = \
+ stats.linregress(x[-n:], np.log(y[-n:]))
+ adj_r = 1 - ((1 - r_value ** 2) * (n - 1)) / (n - 2)
+ # Update lambda, r and m if adj_r has increased
+ if adj_r > r:
+ r = adj_r
+ lambda_z = np.abs(slope)
+ m = n
+ return lambda_z, r ** 2, m
+
+ def _auc_infinity(self):
+ """
+ Calculate total area under the concentration–time curve extrapolating
+ to Inf using the terminal rate constant Lambda_z.
+ :return: auc_inf {float} auc-Inf
+ """
+ auc_inf = self.auc_0_last + self.concentrations[-1] / self.lambda_z
+ return auc_inf
+
+ def _auc_infinity_dose(self):
+ """
+ Calculate auc-Infinity divided by administered dose amount
+ :return: {float} -- auc-Inf Dose = auc-Inf/DM
+ """
+ return self.auc_infinity / self.dose_amount
+
+ def _auc_extrap_percent(self):
+ """
+ Calculate fraction of total auc_infinity obtained from extrapolation
+ :return {float} -- extrapolated percentage
+ """
+ return 100 * (self.auc_infinity - self.auc_0_last) / self.auc_infinity
+
+ def _CL(self):
+ """
+ Calculate total drug clearance (DM/auc-Inf)
+ :return {float} -- total drug clearance CL = DM/auc-Inf
+ """
+ return self.dose_amount / self.auc_infinity
+
+ def _find_Cmax(self):
+ """
+ Find maximum observed concentration and corresponding time
+ :return {float} -- max concentration
+ :return {float} -- time of max conc
+ """
+ if self.is_c0extrapolated: # ignore extrapolated c0
+ indx = np.argmax(self.concentrations[1:]) + 1 # index of maximum
+ else:
+ indx = np.argmax(self.concentrations)
+ return self.concentrations[indx], self.times[indx]
+
+ def _C_max_Dose(self):
+ """
+ Calculate CmaxDose
+ :return: {float} -- CmaxDose = Cmax/DM
+ """
+ return self.c_max / self.dose_amount
+
+ def _aumc(self):
+ """
+ Calculate area under the first moment of the concentration–time curve
+ extrapolated to Inf
+ :return: aumc {float} -- aumc
+ """
+ aumc = self.aumc_0_last + \
+ self.concentrations[-1] / (self.lambda_z**2) + self.times[-1] * \
+ self.concentrations[-1] / self.lambda_z
+ return aumc
+
+ def _aumc_extrap_percent(self):
+ """
+ Calculate fraction of total aumc obtained from extrapolation
+ :return {float} -- extrapolated percentage
+ """
+ return 100 * (self.aumc - self.aumc_0_last) / self.aumc
+
+ def _MRT(self):
+ """
+ Calculate mean residence time (MRT) of drug
+ :return: {float} -- MRT = aumc/auc-Inf
+ """
+ return self.aumc / self.auc_infinity
+
+ def _Tlast(self):
+ """
+ :return: {float} -- time of last observed concentration value
+ """
+ return self.times[-1]
+
+ def _T_half(self):
+ """
+ Calculate terminal half life of drug (time to decay to half amount
+ under terminal rate constant)
+ :return: {float} -- terminal half life
+ """
+ return np.log(2) / self.tlast
+
+ def _V_ss(self):
+ """
+ Calculate apparent volume of distribution at equilibrium. (IV Bolus
+ doses only).
+ :return: {float} -- apparent volume of distribution
+ """
+ return (
+ (self.dose_amount * self.aumc) /
+ (self.auc_infinity * self.lambda_z)
+ )
+
+ def _V_z(self):
+ """
+ Calculate volume of distribution during the terminal phase.
+ :return: volume of distribution
+ """
+ return self.dose_amount / (self.auc_infinity * self.lambda_z)
diff --git a/pkpdapp/pkpdapp/wsgi.py b/pkpdapp/pkpdapp/wsgi.py
new file mode 100644
index 00000000..475d8803
--- /dev/null
+++ b/pkpdapp/pkpdapp/wsgi.py
@@ -0,0 +1,22 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+"""
+WSGI config for pkpdapp project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'pkpdapp.settings')
+
+application = get_wsgi_application()
diff --git a/pkpdapp/schema.yml b/pkpdapp/schema.yml
new file mode 100644
index 00000000..d7b85b2d
--- /dev/null
+++ b/pkpdapp/schema.yml
@@ -0,0 +1,5348 @@
+openapi: 3.0.3
+info:
+ title: PKPDApp API
+ version: 1.0.0
+ description: The API for the PKPDApp
+paths:
+ /api/algorithm/:
+ get:
+ operationId: algorithm_list
+ tags:
+ - algorithm
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ post:
+ operationId: algorithm_create
+ tags:
+ - algorithm
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ /api/algorithm/{id}/:
+ get:
+ operationId: algorithm_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this algorithm.
+ required: true
+ tags:
+ - algorithm
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ put:
+ operationId: algorithm_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this algorithm.
+ required: true
+ tags:
+ - algorithm
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ patch:
+ operationId: algorithm_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this algorithm.
+ required: true
+ tags:
+ - algorithm
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedAlgorithm'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedAlgorithm'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedAlgorithm'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ delete:
+ operationId: algorithm_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this algorithm.
+ required: true
+ tags:
+ - algorithm
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/auce/:
+ post:
+ operationId: auce_create
+ tags:
+ - auce
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/biomarker_type/:
+ get:
+ operationId: biomarker_type_list
+ tags:
+ - biomarker_type
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ post:
+ operationId: biomarker_type_create
+ tags:
+ - biomarker_type
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ /api/biomarker_type/{id}/:
+ get:
+ operationId: biomarker_type_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this biomarker type.
+ required: true
+ tags:
+ - biomarker_type
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ put:
+ operationId: biomarker_type_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this biomarker type.
+ required: true
+ tags:
+ - biomarker_type
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ patch:
+ operationId: biomarker_type_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this biomarker type.
+ required: true
+ tags:
+ - biomarker_type
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedBiomarkerType'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedBiomarkerType'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedBiomarkerType'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ delete:
+ operationId: biomarker_type_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this biomarker type.
+ required: true
+ tags:
+ - biomarker_type
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/combined_model/:
+ get:
+ operationId: combined_model_list
+ parameters:
+ - in: query
+ name: project_id
+ schema:
+ type: integer
+ description: Filter results by project ID
+ tags:
+ - combined_model
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/CombinedModel'
+ description: ''
+ post:
+ operationId: combined_model_create
+ tags:
+ - combined_model
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ description: ''
+ /api/combined_model/{id}/:
+ get:
+ operationId: combined_model_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this combined model.
+ required: true
+ tags:
+ - combined_model
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ description: ''
+ put:
+ operationId: combined_model_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this combined model.
+ required: true
+ tags:
+ - combined_model
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ description: ''
+ patch:
+ operationId: combined_model_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this combined model.
+ required: true
+ tags:
+ - combined_model
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedCombinedModel'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedCombinedModel'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedCombinedModel'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ description: ''
+ delete:
+ operationId: combined_model_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this combined model.
+ required: true
+ tags:
+ - combined_model
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/combined_model/{id}/set_params_to_defaults/:
+ put:
+ operationId: combined_model_set_params_to_defaults_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this combined model.
+ required: true
+ tags:
+ - combined_model
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ description: ''
+ /api/combined_model/{id}/set_variables_from_inference/:
+ put:
+ operationId: combined_model_set_variables_from_inference_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this combined model.
+ required: true
+ tags:
+ - combined_model
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/CombinedModel'
+ description: ''
+ /api/combined_model/{id}/simulate:
+ post:
+ operationId: combined_model_simulate_create
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ required: true
+ tags:
+ - combined_model
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Simulate'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Simulate'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Simulate'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/SimulateResponse'
+ description: ''
+ '400':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ErrorResponse'
+ description: ''
+ '404':
+ description: No response body
+ /api/compound/:
+ get:
+ operationId: compound_list
+ tags:
+ - compound
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ post:
+ operationId: compound_create
+ tags:
+ - compound
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ /api/compound/{id}/:
+ get:
+ operationId: compound_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this compound.
+ required: true
+ tags:
+ - compound
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ put:
+ operationId: compound_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this compound.
+ required: true
+ tags:
+ - compound
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ patch:
+ operationId: compound_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this compound.
+ required: true
+ tags:
+ - compound
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedCompound'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedCompound'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedCompound'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ delete:
+ operationId: compound_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this compound.
+ required: true
+ tags:
+ - compound
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/dataset/:
+ get:
+ operationId: dataset_list
+ tags:
+ - dataset
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ post:
+ operationId: dataset_create
+ tags:
+ - dataset
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ /api/dataset/{id}/:
+ get:
+ operationId: dataset_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ put:
+ operationId: dataset_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ patch:
+ operationId: dataset_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedDataset'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedDataset'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedDataset'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ delete:
+ operationId: dataset_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/dataset/{id}/csv/:
+ put:
+ operationId: dataset_csv_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ requestBody:
+ content:
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/DatasetCsv'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DatasetCsv'
+ description: ''
+ /api/dose/:
+ get:
+ operationId: dose_list
+ tags:
+ - dose
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ post:
+ operationId: dose_create
+ tags:
+ - dose
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ /api/dose/{id}/:
+ get:
+ operationId: dose_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dose.
+ required: true
+ tags:
+ - dose
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ put:
+ operationId: dose_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dose.
+ required: true
+ tags:
+ - dose
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ patch:
+ operationId: dose_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dose.
+ required: true
+ tags:
+ - dose
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedDose'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedDose'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedDose'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ delete:
+ operationId: dose_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dose.
+ required: true
+ tags:
+ - dose
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/inference/:
+ get:
+ operationId: inference_list
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ post:
+ operationId: inference_create
+ tags:
+ - inference
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ /api/inference/{id}/:
+ get:
+ operationId: inference_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference.
+ required: true
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ put:
+ operationId: inference_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference.
+ required: true
+ tags:
+ - inference
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ patch:
+ operationId: inference_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference.
+ required: true
+ tags:
+ - inference
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedInference'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedInference'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedInference'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ delete:
+ operationId: inference_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference.
+ required: true
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/inference/{id}/stop:
+ post:
+ operationId: inference_stop_create
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ required: true
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/inference/wizard:
+ post:
+ operationId: inference_wizard_create
+ description: |-
+ expecting data in the form:
+ {
+
+ # Inference parameters
+ 'id': 1
+ 'name': "my inference run",
+ 'project': 1,
+ 'algorithm': 2,
+ 'initialization_strategy': 'R',
+ 'initialization_inference': 2,
+ 'number_of_chains': 4,
+ 'max_number_of_iterations': 3000,
+ 'burn_in': 0,
+
+ # Model
+ 'model': {
+ 'form': 'PK',
+ 'id': 5
+ }
+ 'dataset': 3,
+
+ # Model parameters
+ 'parameters': [
+ {
+ 'name': 'myokit.parameter1'
+ 'form': 'N',
+ 'pooled': False,
+ 'parameters': [
+ '2 * biomarker[subject_weight]',
+ 'parameter[parameter1_variance]'
+ ]
+ },
+ {
+ 'name': 'parameter1_variance'
+ 'form': 'N',
+ 'parameters': [0, 1]
+ },
+ {
+ 'name': 'myokit.parameter2'
+ 'form': 'U',
+ 'parameters': [-1, 1]
+ },
+ {
+ 'name': 'myokit.parameter3'
+ 'form': 'F',
+ 'parameters': [123.5]
+ },
+ ]
+
+ # output
+ 'observations': [
+ {
+ 'model': 'myokit.plasma_concentration',
+ 'biomarker': 'concentration,
+ 'noise_form': 'N',
+ 'noise_param_form': 'N',
+ 'parameters': [0, 1]
+ },
+ {
+ 'model': 'myokit.bacteria_count',
+ 'biomarker': 'bacteria,
+ 'noise_form': 'LN',
+ 'noise_param_form': 'F'
+ 'parameters': [123.3]
+ },
+ ]
+ }
+
+ Uses model as the base model. If it is a PK or PKPD model, creates a model
+ for each protocol used in the dataset, replacing the protocol of the model
+ with each new one.
+
+ This set of models has a set of parameters. If pooled is True or not given,
+ then parameters of the same qname are assumed to be identical, if pooled is
+ False, then the value of this parameter is different across each subject.
+ All Variable fields from the original model are copied over to the new
+ models. Priors and fixed values for each parameter in this set are provided
+ in 'parameters'. Distribution parameters for each prior can be provided
+ using a python expression, or a number. If a python expression is used, the
+ keywords Parameter[] are used to refer to other parameters in
+ the list. Additional parameters can be added to the list (parameters not in
+ the model) to contruct hierarchical inference. You can refer to biomarkers
+ in the expression using the keyword Biomarker[].
+
+ The 'observations' field maps model output variables with biomarkers in the
+ dataset
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/inference_chain/:
+ get:
+ operationId: inference_chain_list
+ tags:
+ - inference_chain
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ post:
+ operationId: inference_chain_create
+ tags:
+ - inference_chain
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ /api/inference_chain/{id}/:
+ get:
+ operationId: inference_chain_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference chain.
+ required: true
+ tags:
+ - inference_chain
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ put:
+ operationId: inference_chain_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference chain.
+ required: true
+ tags:
+ - inference_chain
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ patch:
+ operationId: inference_chain_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference chain.
+ required: true
+ tags:
+ - inference_chain
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedInferenceChain'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedInferenceChain'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedInferenceChain'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ delete:
+ operationId: inference_chain_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference chain.
+ required: true
+ tags:
+ - inference_chain
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/nca/:
+ post:
+ operationId: nca_create
+ tags:
+ - nca
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/pharmacodynamic/:
+ get:
+ operationId: pharmacodynamic_list
+ tags:
+ - pharmacodynamic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ post:
+ operationId: pharmacodynamic_create
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ /api/pharmacodynamic/{id}/:
+ get:
+ operationId: pharmacodynamic_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ put:
+ operationId: pharmacodynamic_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ patch:
+ operationId: pharmacodynamic_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacodynamic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacodynamic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacodynamic'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ delete:
+ operationId: pharmacodynamic_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/pharmacodynamic/{id}/mmt/:
+ put:
+ operationId: pharmacodynamic_mmt_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ /api/pharmacodynamic/{id}/sbml/:
+ put:
+ operationId: pharmacodynamic_sbml_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PharmacodynamicSbml'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PharmacodynamicSbml'
+ description: ''
+ /api/pharmacodynamic/{id}/set_variables_from_inference/:
+ put:
+ operationId: pharmacodynamic_set_variables_from_inference_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ /api/pharmacodynamic/{id}/simulate:
+ post:
+ operationId: pharmacodynamic_simulate_create
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Simulate'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Simulate'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Simulate'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/SimulateResponse'
+ description: ''
+ '400':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ErrorResponse'
+ description: ''
+ '404':
+ description: No response body
+ /api/pharmacokinetic/:
+ get:
+ operationId: pharmacokinetic_list
+ tags:
+ - pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ post:
+ operationId: pharmacokinetic_create
+ tags:
+ - pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ /api/pharmacokinetic/{id}/:
+ get:
+ operationId: pharmacokinetic_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacokinetic model.
+ required: true
+ tags:
+ - pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ put:
+ operationId: pharmacokinetic_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacokinetic model.
+ required: true
+ tags:
+ - pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ patch:
+ operationId: pharmacokinetic_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacokinetic model.
+ required: true
+ tags:
+ - pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacokinetic'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ delete:
+ operationId: pharmacokinetic_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacokinetic model.
+ required: true
+ tags:
+ - pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/project/:
+ get:
+ operationId: project_list
+ description: Enable partial updates
+ tags:
+ - project
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ post:
+ operationId: project_create
+ description: Enable partial updates
+ tags:
+ - project
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Project'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Project'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ /api/project/{id}/:
+ get:
+ operationId: project_retrieve
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ put:
+ operationId: project_update
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Project'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Project'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ patch:
+ operationId: project_partial_update
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedProject'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedProject'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedProject'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ delete:
+ operationId: project_destroy
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/project/{id}/monolix/:
+ put:
+ operationId: project_monolix_update
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ requestBody:
+ content:
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Monolix'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Monolix'
+ description: ''
+ /api/project_access/:
+ get:
+ operationId: project_access_list
+ tags:
+ - project_access
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ post:
+ operationId: project_access_create
+ tags:
+ - project_access
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ /api/project_access/{id}/:
+ get:
+ operationId: project_access_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project access.
+ required: true
+ tags:
+ - project_access
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ put:
+ operationId: project_access_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project access.
+ required: true
+ tags:
+ - project_access
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ patch:
+ operationId: project_access_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project access.
+ required: true
+ tags:
+ - project_access
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedProjectAccess'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedProjectAccess'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedProjectAccess'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ delete:
+ operationId: project_access_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project access.
+ required: true
+ tags:
+ - project_access
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/protocol/:
+ get:
+ operationId: protocol_list
+ parameters:
+ - in: query
+ name: project_id
+ schema:
+ type: integer
+ description: Filter results by project ID
+ tags:
+ - protocol
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ post:
+ operationId: protocol_create
+ tags:
+ - protocol
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ /api/protocol/{id}/:
+ get:
+ operationId: protocol_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this protocol.
+ required: true
+ tags:
+ - protocol
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ put:
+ operationId: protocol_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this protocol.
+ required: true
+ tags:
+ - protocol
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ patch:
+ operationId: protocol_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this protocol.
+ required: true
+ tags:
+ - protocol
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedProtocol'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedProtocol'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedProtocol'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ delete:
+ operationId: protocol_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this protocol.
+ required: true
+ tags:
+ - protocol
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/session/:
+ get:
+ operationId: session_retrieve
+ tags:
+ - session
+ security:
+ - cookieAuth: []
+ - basicAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/simulation/:
+ get:
+ operationId: simulation_list
+ parameters:
+ - in: query
+ name: project_id
+ schema:
+ type: integer
+ description: Filter results by project ID
+ tags:
+ - simulation
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Simulation'
+ description: ''
+ post:
+ operationId: simulation_create
+ tags:
+ - simulation
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ description: ''
+ /api/simulation/{id}/:
+ get:
+ operationId: simulation_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this simulation.
+ required: true
+ tags:
+ - simulation
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ description: ''
+ put:
+ operationId: simulation_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this simulation.
+ required: true
+ tags:
+ - simulation
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ description: ''
+ patch:
+ operationId: simulation_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this simulation.
+ required: true
+ tags:
+ - simulation
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedSimulation'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedSimulation'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedSimulation'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Simulation'
+ description: ''
+ delete:
+ operationId: simulation_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this simulation.
+ required: true
+ tags:
+ - simulation
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/subject/:
+ get:
+ operationId: subject_list
+ tags:
+ - subject
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ post:
+ operationId: subject_create
+ tags:
+ - subject
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ /api/subject/{id}/:
+ get:
+ operationId: subject_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this subject.
+ required: true
+ tags:
+ - subject
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ put:
+ operationId: subject_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this subject.
+ required: true
+ tags:
+ - subject
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ patch:
+ operationId: subject_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this subject.
+ required: true
+ tags:
+ - subject
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedSubject'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedSubject'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedSubject'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ delete:
+ operationId: subject_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this subject.
+ required: true
+ tags:
+ - subject
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/unit/:
+ get:
+ operationId: unit_list
+ parameters:
+ - in: query
+ name: compound_id
+ schema:
+ type: integer
+ description: Enable conversions based on compound information
+ tags:
+ - unit
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ post:
+ operationId: unit_create
+ tags:
+ - unit
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ /api/unit/{id}/:
+ get:
+ operationId: unit_retrieve
+ parameters:
+ - in: query
+ name: compound_id
+ schema:
+ type: integer
+ description: Enable conversions based on compound information
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this unit.
+ required: true
+ tags:
+ - unit
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ put:
+ operationId: unit_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this unit.
+ required: true
+ tags:
+ - unit
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ patch:
+ operationId: unit_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this unit.
+ required: true
+ tags:
+ - unit
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedUnit'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedUnit'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedUnit'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ delete:
+ operationId: unit_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this unit.
+ required: true
+ tags:
+ - unit
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/user/:
+ get:
+ operationId: user_list
+ tags:
+ - user
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/User'
+ description: ''
+ post:
+ operationId: user_create
+ tags:
+ - user
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/User'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/User'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ description: ''
+ /api/user/{id}/:
+ get:
+ operationId: user_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this user.
+ required: true
+ tags:
+ - user
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ description: ''
+ put:
+ operationId: user_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this user.
+ required: true
+ tags:
+ - user
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/User'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/User'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ description: ''
+ patch:
+ operationId: user_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this user.
+ required: true
+ tags:
+ - user
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedUser'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedUser'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedUser'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ description: ''
+ delete:
+ operationId: user_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this user.
+ required: true
+ tags:
+ - user
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/variable/:
+ get:
+ operationId: variable_list
+ parameters:
+ - in: query
+ name: dosed_pk_model_id
+ schema:
+ type: integer
+ description: Filter results by dosed_pk_model ID
+ - in: query
+ name: pd_model_id
+ schema:
+ type: integer
+ description: Filter results by pd_model ID
+ - in: query
+ name: project_id
+ schema:
+ type: integer
+ description: Filter results by project ID
+ tags:
+ - variable
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ post:
+ operationId: variable_create
+ tags:
+ - variable
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ /api/variable/{id}/:
+ get:
+ operationId: variable_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this variable.
+ required: true
+ tags:
+ - variable
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ put:
+ operationId: variable_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this variable.
+ required: true
+ tags:
+ - variable
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ patch:
+ operationId: variable_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this variable.
+ required: true
+ tags:
+ - variable
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedVariable'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedVariable'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedVariable'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ delete:
+ operationId: variable_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this variable.
+ required: true
+ tags:
+ - variable
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/whoami/:
+ get:
+ operationId: whoami_retrieve
+ tags:
+ - whoami
+ security:
+ - cookieAuth: []
+ - basicAuth: []
+ responses:
+ '200':
+ description: No response body
+components:
+ schemas:
+ Algorithm:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of the algorithm
+ maxLength: 100
+ category:
+ $ref: '#/components/schemas/CategoryEnum'
+ required:
+ - category
+ - id
+ - name
+ BiomarkerType:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ data:
+ type: object
+ additionalProperties:
+ type: array
+ items: {}
+ nullable: true
+ readOnly: true
+ is_continuous:
+ type: boolean
+ readOnly: true
+ is_categorical:
+ type: boolean
+ readOnly: true
+ name:
+ type: string
+ description: name of the biomarker type
+ maxLength: 100
+ description:
+ type: string
+ nullable: true
+ description: short description of the biomarker type
+ display:
+ type: boolean
+ description: True if this biomarker type will be displayed in the frontend,
+ False otherwise
+ color:
+ type: integer
+ description: Color index associated with this biomarker type. For plotting
+ purposes in the frontend
+ axis:
+ type: boolean
+ description: True/False if biomarker type displayed on LHS/RHS axis
+ stored_unit:
+ type: integer
+ description: unit for the value stored in :model:`pkpdapp.Biomarker`
+ dataset:
+ type: integer
+ description: dataset containing this biomarker measurement
+ display_unit:
+ type: integer
+ description: unit to use when sending or displaying biomarker values
+ stored_time_unit:
+ type: integer
+ description: unit for the time values stored in :model:`pkpdapp.Biomarker`
+ display_time_unit:
+ type: integer
+ description: unit to use when sending or displaying time values
+ required:
+ - data
+ - dataset
+ - display_time_unit
+ - display_unit
+ - id
+ - is_categorical
+ - is_continuous
+ - name
+ - stored_time_unit
+ - stored_unit
+ CategoryEnum:
+ enum:
+ - SA
+ - OP
+ - OT
+ type: string
+ description: |-
+ * `SA` - Sampling
+ * `OP` - Optimisation
+ * `OT` - Optimisation
+ CombinedModel:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ mappings:
+ type: array
+ items:
+ $ref: '#/components/schemas/PkpdMapping'
+ derived_variables:
+ type: array
+ items:
+ $ref: '#/components/schemas/DerivedVariable'
+ components:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ mmt:
+ type: string
+ readOnly: true
+ time_unit:
+ type: integer
+ readOnly: true
+ is_library_model:
+ type: boolean
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ species:
+ allOf:
+ - $ref: '#/components/schemas/CombinedModelSpeciesEnum'
+ description: |-
+ species
+
+ * `H` - human
+ * `R` - rat
+ * `N` - non-human primate
+ * `M` - mouse
+ has_saturation:
+ type: boolean
+ description: whether the pk model has saturation
+ has_effect:
+ type: boolean
+ description: whether the pk model has effect compartment
+ has_lag:
+ type: boolean
+ description: whether the pk model has lag
+ has_bioavailability:
+ type: boolean
+ description: whether the pk model has bioavailability
+ has_hill_coefficient:
+ type: boolean
+ description: whether the pd model has hill coefficient
+ time_max:
+ type: number
+ format: double
+ description: suggested time to simulate after the last dose (in the time
+ units specified by the mmt model)
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ pk_model:
+ type: integer
+ nullable: true
+ description: model
+ pd_model:
+ type: integer
+ nullable: true
+ description: PD part of model
+ pd_model2:
+ type: integer
+ nullable: true
+ description: second PD part of model
+ required:
+ - components
+ - derived_variables
+ - id
+ - is_library_model
+ - mappings
+ - mmt
+ - name
+ - time_unit
+ - variables
+ CombinedModelSpeciesEnum:
+ enum:
+ - H
+ - R
+ - N
+ - M
+ type: string
+ description: |-
+ * `H` - human
+ * `R` - rat
+ * `N` - non-human primate
+ * `M` - mouse
+ Compound:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ efficacy_experiments:
+ type: array
+ items:
+ $ref: '#/components/schemas/Efficacy'
+ name:
+ type: string
+ description: name of the compound
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the compound
+ molecular_mass:
+ type: number
+ format: double
+ description: molecular mass for compound for conversion from mol to grams
+ compound_type:
+ $ref: '#/components/schemas/CompoundTypeEnum'
+ fraction_unbound_plasma:
+ type: number
+ format: double
+ nullable: true
+ description: fraction unbound plasma (unitless)
+ blood_to_plasma_ratio:
+ type: number
+ format: double
+ nullable: true
+ description: blood to plasma ratio (unitless)
+ intrinsic_clearance:
+ type: number
+ format: double
+ nullable: true
+ description: intrinsic clearance
+ intrinsic_clearance_assay:
+ $ref: '#/components/schemas/IntrinsicClearanceAssayEnum'
+ fraction_unbound_including_cells:
+ type: number
+ format: double
+ nullable: true
+ description: fraction unbound in plasma and red blood cells (unitless)
+ target_molecular_mass:
+ type: number
+ format: double
+ description: molecular mass for target for conversion from mol to grams
+ target_concentration:
+ type: number
+ format: double
+ nullable: true
+ description: target concentration
+ dissociation_constant:
+ type: number
+ format: double
+ nullable: true
+ description: dissociation constant
+ is_soluble:
+ type: boolean
+ description: is the compound target soluble
+ use_efficacy:
+ type: integer
+ nullable: true
+ molecular_mass_unit:
+ type: integer
+ description: unit for molecular mass (e.g. g/mol)
+ intrinsic_clearance_unit:
+ type: integer
+ description: unit for intrinsic clearance
+ target_molecular_mass_unit:
+ type: integer
+ description: unit for target molecular mass (e.g. g/mol)
+ target_concentration_unit:
+ type: integer
+ description: unit for target concentration
+ dissociation_unit:
+ type: integer
+ description: unit for dissociation constant
+ required:
+ - efficacy_experiments
+ - id
+ - name
+ CompoundTypeEnum:
+ enum:
+ - SM
+ - LM
+ type: string
+ description: |-
+ * `SM` - Small Molecule
+ * `LM` - Large Molecule
+ Dataset:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ biomarker_types:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ subjects:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ protocols:
+ type: array
+ items:
+ $ref: '#/components/schemas/Protocol'
+ readOnly: true
+ name:
+ type: string
+ description: name of the dataset
+ maxLength: 100
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: date/time the experiment was conducted. All time measurements
+ are relative to this date/time, which is in YYYY-MM-DD HH:MM:SS format.
+ For example, 2020-07-18 14:30:59
+ description:
+ type: string
+ description: short description of the dataset
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ required:
+ - biomarker_types
+ - id
+ - name
+ - protocols
+ - subjects
+ DatasetCsv:
+ type: object
+ properties:
+ csv:
+ type: string
+ format: uri
+ required:
+ - csv
+ DerivedVariable:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ type:
+ allOf:
+ - $ref: '#/components/schemas/TypeEnum'
+ description: |-
+ type of derived variable
+
+ * `RO` - receptor occupancy
+ * `FUP` - faction unbound plasma
+ * `BPR` - blood plasma ratio
+ * `TLG` - dosing lag time
+ pkpd_model:
+ type: integer
+ description: PKPD model that this derived variable is for
+ pk_variable:
+ type: integer
+ description: base variable in PK part of model
+ required:
+ - id
+ - pk_variable
+ - pkpd_model
+ - type
+ Dose:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ start_time:
+ type: number
+ format: double
+ description: starting time point of dose, see protocol for units
+ amount:
+ type: number
+ format: double
+ description: amount of compound administered over the duration, see protocol
+ for units. Rate of administration is assumed constant
+ duration:
+ type: number
+ format: double
+ description: Duration of dose administration, see protocol for units. Duration
+ must be greater than 0.
+ repeats:
+ type: integer
+ description: 'Number of times to repeat the dose. '
+ repeat_interval:
+ type: number
+ format: double
+ description: 'Interval between repeated doses. See protocol for units. '
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ required:
+ - amount
+ - id
+ - start_time
+ DoseTypeEnum:
+ enum:
+ - D
+ - I
+ type: string
+ description: |-
+ * `D` - IV
+ * `I` - Extravascular
+ Efficacy:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of the experiment
+ maxLength: 100
+ c50:
+ type: number
+ format: double
+ description: half maximal effective concentration
+ hill_coefficient:
+ type: number
+ format: double
+ description: Hill coefficient measure of binding
+ c50_unit:
+ type: integer
+ description: unit for c50
+ compound:
+ type: integer
+ description: compound for efficacy experiment
+ required:
+ - c50
+ - c50_unit
+ - compound
+ - id
+ ErrorResponse:
+ type: object
+ properties:
+ error:
+ type: string
+ required:
+ - error
+ FormEnum:
+ enum:
+ - N
+ - U
+ - LN
+ - F
+ - S
+ - E
+ - M
+ type: string
+ description: |-
+ * `N` - Normal
+ * `U` - Uniform
+ * `LN` - Log-Normal
+ * `F` - Fixed
+ * `S` - Sum
+ * `E` - Equation
+ * `M` - Model
+ Inference:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ log_likelihoods:
+ type: array
+ items:
+ $ref: '#/components/schemas/LogLikelihood'
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the dataset
+ maxLength: 100
+ description:
+ type: string
+ description: short description of what this inference does
+ initialization_strategy:
+ $ref: '#/components/schemas/InitializationStrategyEnum'
+ number_of_chains:
+ type: integer
+ description: number of chains
+ max_number_of_iterations:
+ type: integer
+ description: maximum number of iterations
+ burn_in:
+ type: integer
+ description: final iteration of burn-in
+ number_of_iterations:
+ type: integer
+ description: number of iterations calculated
+ time_elapsed:
+ type: integer
+ description: Elapsed run time for inference in seconds
+ number_of_function_evals:
+ type: integer
+ description: number of function evaluations
+ task_id:
+ type: string
+ nullable: true
+ description: If executing, this is the celery task id
+ maxLength: 40
+ metadata:
+ type: object
+ additionalProperties: {}
+ description: metadata for inference
+ project:
+ type: integer
+ description: Project that "owns" this inference object
+ algorithm:
+ type: integer
+ description: algorithm used to perform the inference
+ initialization_inference:
+ type: integer
+ nullable: true
+ required:
+ - id
+ - log_likelihoods
+ - name
+ - project
+ InferenceChain:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ data:
+ type: string
+ readOnly: true
+ outputs:
+ type: string
+ readOnly: true
+ inference:
+ type: integer
+ description: inference for this chain
+ required:
+ - data
+ - id
+ - inference
+ - outputs
+ InitializationStrategyEnum:
+ enum:
+ - D
+ - R
+ - F
+ type: string
+ description: |-
+ * `D` - Default Value of model
+ * `R` - Random from prior
+ * `F` - From other inference
+ IntrinsicClearanceAssayEnum:
+ enum:
+ - MS
+ - HC
+ type: string
+ description: |-
+ * `MS` - Microsomes
+ * `HC` - Hepatocytes
+ LogLikelihood:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ parameters:
+ type: array
+ items:
+ $ref: '#/components/schemas/LogLikelihoodParameter'
+ model:
+ type: array
+ items:
+ type: string
+ minLength: 2
+ maxLength: 2
+ nullable: true
+ readOnly: true
+ dataset:
+ type: integer
+ nullable: true
+ readOnly: true
+ time_variable:
+ type: integer
+ nullable: true
+ readOnly: true
+ is_a_prior:
+ type: boolean
+ readOnly: true
+ name:
+ type: string
+ description: name of log_likelihood.
+ maxLength: 100
+ description:
+ type: string
+ nullable: true
+ description: 'description of log_likelihood. For equations will be the code
+ of that equation using Python syntax: arg1 * arg2^arg3'
+ value:
+ type: number
+ format: double
+ nullable: true
+ description: set if a fixed value is required
+ time_independent_data:
+ type: boolean
+ description: 'True if biomarker_type refers to time-independent data. If
+ there are multiple timepoints in biomarker_type then only the first is
+ taken '
+ observed:
+ type: boolean
+ description: 'True if this log_likelihood is observed '
+ form:
+ $ref: '#/components/schemas/FormEnum'
+ inference:
+ type: integer
+ readOnly: true
+ description: 'Log_likelihood belongs to this inference object. '
+ variable:
+ type: integer
+ nullable: true
+ description: 'If form=MODEL, a variable (any) in the deterministic model. '
+ biomarker_type:
+ type: integer
+ nullable: true
+ description: data associated with this log_likelihood. This is used for
+ measurement data (observed=True) or for covariates (observed=False). The
+ random variable associated with this log_likelihood has the same shape
+ as this data. For covariates the subject ids in the data correspond to
+ the values of the random variable at that location.
+ protocol_filter:
+ type: integer
+ nullable: true
+ description: filter subject data on this protocol(null implies all subjects)
+ children:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ required:
+ - children
+ - dataset
+ - id
+ - inference
+ - is_a_prior
+ - model
+ - name
+ - parameters
+ - time_variable
+ LogLikelihoodParameter:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of log_likelihood parameter.
+ maxLength: 100
+ parent_index:
+ type: integer
+ nullable: true
+ description: parameter index for distribution and equation parameters. blank
+ for models (variable is used instead)
+ child_index:
+ type: integer
+ description: 'output index for all log_likelihoods. '
+ length:
+ type: integer
+ nullable: true
+ description: length of array representing parameter. null for scalar
+ parent:
+ type: integer
+ readOnly: true
+ child:
+ type: integer
+ variable:
+ type: integer
+ nullable: true
+ description: input model variable for this parameter.
+ required:
+ - child
+ - id
+ - name
+ - parent
+ Monolix:
+ type: object
+ properties:
+ data_csv:
+ type: string
+ format: uri
+ writeOnly: true
+ model_txt:
+ type: string
+ format: uri
+ writeOnly: true
+ project_mlxtran:
+ type: string
+ format: uri
+ writeOnly: true
+ data:
+ type: string
+ readOnly: true
+ pd_model:
+ type: string
+ readOnly: true
+ pk_model:
+ type: string
+ readOnly: true
+ required:
+ - data
+ - data_csv
+ - model_txt
+ - pd_model
+ - pk_model
+ - project_mlxtran
+ PatchedAlgorithm:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of the algorithm
+ maxLength: 100
+ category:
+ $ref: '#/components/schemas/CategoryEnum'
+ PatchedBiomarkerType:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ data:
+ type: object
+ additionalProperties:
+ type: array
+ items: {}
+ nullable: true
+ readOnly: true
+ is_continuous:
+ type: boolean
+ readOnly: true
+ is_categorical:
+ type: boolean
+ readOnly: true
+ name:
+ type: string
+ description: name of the biomarker type
+ maxLength: 100
+ description:
+ type: string
+ nullable: true
+ description: short description of the biomarker type
+ display:
+ type: boolean
+ description: True if this biomarker type will be displayed in the frontend,
+ False otherwise
+ color:
+ type: integer
+ description: Color index associated with this biomarker type. For plotting
+ purposes in the frontend
+ axis:
+ type: boolean
+ description: True/False if biomarker type displayed on LHS/RHS axis
+ stored_unit:
+ type: integer
+ description: unit for the value stored in :model:`pkpdapp.Biomarker`
+ dataset:
+ type: integer
+ description: dataset containing this biomarker measurement
+ display_unit:
+ type: integer
+ description: unit to use when sending or displaying biomarker values
+ stored_time_unit:
+ type: integer
+ description: unit for the time values stored in :model:`pkpdapp.Biomarker`
+ display_time_unit:
+ type: integer
+ description: unit to use when sending or displaying time values
+ PatchedCombinedModel:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ mappings:
+ type: array
+ items:
+ $ref: '#/components/schemas/PkpdMapping'
+ derived_variables:
+ type: array
+ items:
+ $ref: '#/components/schemas/DerivedVariable'
+ components:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ mmt:
+ type: string
+ readOnly: true
+ time_unit:
+ type: integer
+ readOnly: true
+ is_library_model:
+ type: boolean
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ species:
+ allOf:
+ - $ref: '#/components/schemas/CombinedModelSpeciesEnum'
+ description: |-
+ species
+
+ * `H` - human
+ * `R` - rat
+ * `N` - non-human primate
+ * `M` - mouse
+ has_saturation:
+ type: boolean
+ description: whether the pk model has saturation
+ has_effect:
+ type: boolean
+ description: whether the pk model has effect compartment
+ has_lag:
+ type: boolean
+ description: whether the pk model has lag
+ has_bioavailability:
+ type: boolean
+ description: whether the pk model has bioavailability
+ has_hill_coefficient:
+ type: boolean
+ description: whether the pd model has hill coefficient
+ time_max:
+ type: number
+ format: double
+ description: suggested time to simulate after the last dose (in the time
+ units specified by the mmt model)
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ pk_model:
+ type: integer
+ nullable: true
+ description: model
+ pd_model:
+ type: integer
+ nullable: true
+ description: PD part of model
+ pd_model2:
+ type: integer
+ nullable: true
+ description: second PD part of model
+ PatchedCompound:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ efficacy_experiments:
+ type: array
+ items:
+ $ref: '#/components/schemas/Efficacy'
+ name:
+ type: string
+ description: name of the compound
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the compound
+ molecular_mass:
+ type: number
+ format: double
+ description: molecular mass for compound for conversion from mol to grams
+ compound_type:
+ $ref: '#/components/schemas/CompoundTypeEnum'
+ fraction_unbound_plasma:
+ type: number
+ format: double
+ nullable: true
+ description: fraction unbound plasma (unitless)
+ blood_to_plasma_ratio:
+ type: number
+ format: double
+ nullable: true
+ description: blood to plasma ratio (unitless)
+ intrinsic_clearance:
+ type: number
+ format: double
+ nullable: true
+ description: intrinsic clearance
+ intrinsic_clearance_assay:
+ $ref: '#/components/schemas/IntrinsicClearanceAssayEnum'
+ fraction_unbound_including_cells:
+ type: number
+ format: double
+ nullable: true
+ description: fraction unbound in plasma and red blood cells (unitless)
+ target_molecular_mass:
+ type: number
+ format: double
+ description: molecular mass for target for conversion from mol to grams
+ target_concentration:
+ type: number
+ format: double
+ nullable: true
+ description: target concentration
+ dissociation_constant:
+ type: number
+ format: double
+ nullable: true
+ description: dissociation constant
+ is_soluble:
+ type: boolean
+ description: is the compound target soluble
+ use_efficacy:
+ type: integer
+ nullable: true
+ molecular_mass_unit:
+ type: integer
+ description: unit for molecular mass (e.g. g/mol)
+ intrinsic_clearance_unit:
+ type: integer
+ description: unit for intrinsic clearance
+ target_molecular_mass_unit:
+ type: integer
+ description: unit for target molecular mass (e.g. g/mol)
+ target_concentration_unit:
+ type: integer
+ description: unit for target concentration
+ dissociation_unit:
+ type: integer
+ description: unit for dissociation constant
+ PatchedDataset:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ biomarker_types:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ subjects:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ protocols:
+ type: array
+ items:
+ $ref: '#/components/schemas/Protocol'
+ readOnly: true
+ name:
+ type: string
+ description: name of the dataset
+ maxLength: 100
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: date/time the experiment was conducted. All time measurements
+ are relative to this date/time, which is in YYYY-MM-DD HH:MM:SS format.
+ For example, 2020-07-18 14:30:59
+ description:
+ type: string
+ description: short description of the dataset
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ PatchedDose:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ start_time:
+ type: number
+ format: double
+ description: starting time point of dose, see protocol for units
+ amount:
+ type: number
+ format: double
+ description: amount of compound administered over the duration, see protocol
+ for units. Rate of administration is assumed constant
+ duration:
+ type: number
+ format: double
+ description: Duration of dose administration, see protocol for units. Duration
+ must be greater than 0.
+ repeats:
+ type: integer
+ description: 'Number of times to repeat the dose. '
+ repeat_interval:
+ type: number
+ format: double
+ description: 'Interval between repeated doses. See protocol for units. '
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ PatchedInference:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ log_likelihoods:
+ type: array
+ items:
+ $ref: '#/components/schemas/LogLikelihood'
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the dataset
+ maxLength: 100
+ description:
+ type: string
+ description: short description of what this inference does
+ initialization_strategy:
+ $ref: '#/components/schemas/InitializationStrategyEnum'
+ number_of_chains:
+ type: integer
+ description: number of chains
+ max_number_of_iterations:
+ type: integer
+ description: maximum number of iterations
+ burn_in:
+ type: integer
+ description: final iteration of burn-in
+ number_of_iterations:
+ type: integer
+ description: number of iterations calculated
+ time_elapsed:
+ type: integer
+ description: Elapsed run time for inference in seconds
+ number_of_function_evals:
+ type: integer
+ description: number of function evaluations
+ task_id:
+ type: string
+ nullable: true
+ description: If executing, this is the celery task id
+ maxLength: 40
+ metadata:
+ type: object
+ additionalProperties: {}
+ description: metadata for inference
+ project:
+ type: integer
+ description: Project that "owns" this inference object
+ algorithm:
+ type: integer
+ description: algorithm used to perform the inference
+ initialization_inference:
+ type: integer
+ nullable: true
+ PatchedInferenceChain:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ data:
+ type: string
+ readOnly: true
+ outputs:
+ type: string
+ readOnly: true
+ inference:
+ type: integer
+ description: inference for this chain
+ PatchedPharmacodynamic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ components:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ mmt:
+ type: string
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the model
+ time_max:
+ type: number
+ format: double
+ description: suggested maximum time to simulate for this model (in the time
+ units specified by the mmt model)
+ is_library_model:
+ type: boolean
+ description: whether this model is a library model (i.e. it is not an uploaded
+ user model)
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ PatchedPharmacokinetic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the model
+ mmt:
+ type: string
+ description: the model represented using mmt (see https://myokit.readthedocs)
+ time_max:
+ type: number
+ format: double
+ description: suggested maximum time to simulate for this model (in the time
+ units specified by the mmt model)
+ is_library_model:
+ type: boolean
+ description: whether this model is a library model (i.e. it is not an uploaded
+ user model)
+ PatchedProject:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ user_access:
+ type: array
+ items:
+ $ref: '#/components/schemas/ProjectAccess'
+ protocols:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of the project
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the project
+ created:
+ type: string
+ format: date-time
+ readOnly: true
+ species:
+ allOf:
+ - $ref: '#/components/schemas/ProjectSpeciesEnum'
+ description: |-
+ subject species
+
+ * `M` - Mouse
+ * `R` - Rat
+ * `H` - Human
+ * `K` - Monkey
+ * `O` - Other
+ compound:
+ type: integer
+ users:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ description: users with access to this project
+ PatchedProjectAccess:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: True if user has read access only
+ user:
+ type: integer
+ project:
+ type: integer
+ readOnly: true
+ PatchedProtocol:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ doses:
+ type: array
+ items:
+ $ref: '#/components/schemas/Dose'
+ dataset:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ subjects:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the protocol
+ maxLength: 100
+ dose_type:
+ $ref: '#/components/schemas/DoseTypeEnum'
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this protocol.
+ compound:
+ type: integer
+ nullable: true
+ description: drug compound
+ time_unit:
+ type: integer
+ nullable: true
+ description: unit for the start_time and duration values stored in each
+ dose
+ amount_unit:
+ type: integer
+ nullable: true
+ description: unit for the amount value stored in each dose
+ PatchedSimulation:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ sliders:
+ type: array
+ items:
+ $ref: '#/components/schemas/SimulationSlider'
+ plots:
+ type: array
+ items:
+ $ref: '#/components/schemas/SimulationPlot'
+ name:
+ type: string
+ description: name of the simulation
+ maxLength: 100
+ nrows:
+ type: integer
+ description: number of subplot rows
+ ncols:
+ type: integer
+ description: number of subplot columns
+ time_max:
+ type: number
+ format: double
+ minimum: 0
+ description: maximum time for the simulation
+ abs_tolerance:
+ type: number
+ format: double
+ minimum: 0
+ description: absolute tolerance for the simulation
+ rel_tolerance:
+ type: number
+ format: double
+ minimum: 0
+ description: relative tolerance for the simulation
+ project:
+ type: integer
+ time_max_unit:
+ type: integer
+ description: unit for maximum time
+ PatchedSubject:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ id_in_dataset:
+ type: integer
+ description: unique id in the dataset
+ shape:
+ type: integer
+ description: Shape index associated with this subject. For plotting purposes
+ in the frontend
+ display:
+ type: boolean
+ description: True if this subject will be displayed in the frontend, False
+ otherwise
+ metadata:
+ type: string
+ description: subject metadata
+ dataset:
+ type: integer
+ description: dataset containing this subject
+ protocol:
+ type: integer
+ nullable: true
+ description: dosing protocol for this subject.
+ PatchedUnit:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ compatible_units:
+ type: array
+ items:
+ type: object
+ additionalProperties:
+ type: string
+ readOnly: true
+ symbol:
+ type: string
+ description: symbol for unit display
+ maxLength: 50
+ g:
+ type: number
+ format: double
+ description: grams exponent
+ m:
+ type: number
+ format: double
+ description: meters exponent
+ s:
+ type: number
+ format: double
+ description: seconds exponent
+ A:
+ type: number
+ format: double
+ description: ampere exponent
+ K:
+ type: number
+ format: double
+ description: kelvin exponent
+ cd:
+ type: number
+ format: double
+ description: candela exponent
+ mol:
+ type: number
+ format: double
+ description: mole exponent
+ multiplier:
+ type: number
+ format: double
+ description: multiplier in powers of 10
+ PatchedUser:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ username:
+ type: string
+ description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
+ only.
+ pattern: ^[\w.@+-]+$
+ maxLength: 150
+ first_name:
+ type: string
+ maxLength: 150
+ last_name:
+ type: string
+ maxLength: 150
+ email:
+ type: string
+ format: email
+ title: Email address
+ maxLength: 254
+ profile:
+ allOf:
+ - $ref: '#/components/schemas/Profile'
+ readOnly: true
+ project_set:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ PatchedVariable:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ is_public:
+ type: boolean
+ lower_bound:
+ type: number
+ format: double
+ nullable: true
+ description: lowest possible value for this variable
+ upper_bound:
+ type: number
+ format: double
+ nullable: true
+ description: largest possible value for this variable
+ default_value:
+ type: number
+ format: double
+ description: default value for this variable
+ is_log:
+ type: boolean
+ description: True if default_value is stored as the log of this value
+ name:
+ type: string
+ description: name of the variable
+ maxLength: 100
+ description:
+ type: string
+ nullable: true
+ description: description of the variable
+ binding:
+ type: string
+ nullable: true
+ description: myokit binding of the variable (e.g. time)
+ maxLength: 100
+ qname:
+ type: string
+ description: fully qualitifed name of the variable
+ maxLength: 200
+ unit_symbol:
+ type: string
+ nullable: true
+ description: if unit is None then this is the unit of this variable as a
+ string
+ maxLength: 20
+ constant:
+ type: boolean
+ description: True for a constant variable of the model, i.e. a parameter.
+ False if non-constant, i.e. an output of the model (default is True)
+ state:
+ type: boolean
+ description: True if it is a state variable of the model and has an initial
+ condition parameter (default is False)
+ color:
+ type: integer
+ description: Color index associated with this variable. For display purposes
+ in the frontend
+ display:
+ type: boolean
+ description: True if this variable will be displayed in the frontend, False
+ otherwise
+ axis:
+ type: boolean
+ description: False/True if biomarker type displayed on LHS/RHS axis
+ unit:
+ type: integer
+ nullable: true
+ description: variable values are in this unit (note this might be different
+ from the unit in the stored sbml)
+ pd_model:
+ type: integer
+ nullable: true
+ description: pharmacodynamic model
+ pk_model:
+ type: integer
+ nullable: true
+ description: pharmacokinetic model
+ dosed_pk_model:
+ type: integer
+ nullable: true
+ description: dosed pharmacokinetic model
+ protocol:
+ type: integer
+ nullable: true
+ description: dosing protocol
+ Pharmacodynamic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ components:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ mmt:
+ type: string
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the model
+ time_max:
+ type: number
+ format: double
+ description: suggested maximum time to simulate for this model (in the time
+ units specified by the mmt model)
+ is_library_model:
+ type: boolean
+ description: whether this model is a library model (i.e. it is not an uploaded
+ user model)
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ required:
+ - components
+ - id
+ - name
+ - variables
+ PharmacodynamicSbml:
+ type: object
+ properties:
+ sbml:
+ type: string
+ writeOnly: true
+ required:
+ - sbml
+ Pharmacokinetic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the model
+ mmt:
+ type: string
+ description: the model represented using mmt (see https://myokit.readthedocs)
+ time_max:
+ type: number
+ format: double
+ description: suggested maximum time to simulate for this model (in the time
+ units specified by the mmt model)
+ is_library_model:
+ type: boolean
+ description: whether this model is a library model (i.e. it is not an uploaded
+ user model)
+ required:
+ - id
+ - name
+ PkpdMapping:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ datetime:
+ type: string
+ format: date
+ readOnly: true
+ read_only:
+ type: boolean
+ readOnly: true
+ pkpd_model:
+ type: integer
+ description: PKPD model that this mapping is for
+ pk_variable:
+ type: integer
+ description: variable in PK part of model
+ pd_variable:
+ type: integer
+ description: variable in PD part of model
+ required:
+ - datetime
+ - id
+ - pd_variable
+ - pk_variable
+ - pkpd_model
+ - read_only
+ Profile:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ user:
+ type: integer
+ required:
+ - id
+ - user
+ Project:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ user_access:
+ type: array
+ items:
+ $ref: '#/components/schemas/ProjectAccess'
+ protocols:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of the project
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the project
+ created:
+ type: string
+ format: date-time
+ readOnly: true
+ species:
+ allOf:
+ - $ref: '#/components/schemas/ProjectSpeciesEnum'
+ description: |-
+ subject species
+
+ * `M` - Mouse
+ * `R` - Rat
+ * `H` - Human
+ * `K` - Monkey
+ * `O` - Other
+ compound:
+ type: integer
+ users:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ description: users with access to this project
+ required:
+ - compound
+ - created
+ - id
+ - name
+ - protocols
+ - user_access
+ - users
+ ProjectAccess:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: True if user has read access only
+ user:
+ type: integer
+ project:
+ type: integer
+ readOnly: true
+ required:
+ - id
+ - project
+ - user
+ ProjectSpeciesEnum:
+ enum:
+ - M
+ - R
+ - H
+ - K
+ - O
+ type: string
+ description: |-
+ * `M` - Mouse
+ * `R` - Rat
+ * `H` - Human
+ * `K` - Monkey
+ * `O` - Other
+ Protocol:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ doses:
+ type: array
+ items:
+ $ref: '#/components/schemas/Dose'
+ dataset:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ subjects:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the protocol
+ maxLength: 100
+ dose_type:
+ $ref: '#/components/schemas/DoseTypeEnum'
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this protocol.
+ compound:
+ type: integer
+ nullable: true
+ description: drug compound
+ time_unit:
+ type: integer
+ nullable: true
+ description: unit for the start_time and duration values stored in each
+ dose
+ amount_unit:
+ type: integer
+ nullable: true
+ description: unit for the amount value stored in each dose
+ required:
+ - dataset
+ - doses
+ - id
+ - name
+ - subjects
+ - variables
+ Simulate:
+ type: object
+ properties:
+ outputs:
+ type: array
+ items:
+ type: string
+ variables:
+ type: object
+ additionalProperties:
+ type: number
+ format: double
+ time_max:
+ type: number
+ format: double
+ required:
+ - outputs
+ - variables
+ SimulateResponse:
+ type: object
+ properties:
+ time:
+ type: array
+ items:
+ type: number
+ format: double
+ outputs:
+ type: object
+ additionalProperties:
+ type: array
+ items:
+ type: number
+ format: double
+ required:
+ - outputs
+ - time
+ Simulation:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ sliders:
+ type: array
+ items:
+ $ref: '#/components/schemas/SimulationSlider'
+ plots:
+ type: array
+ items:
+ $ref: '#/components/schemas/SimulationPlot'
+ name:
+ type: string
+ description: name of the simulation
+ maxLength: 100
+ nrows:
+ type: integer
+ description: number of subplot rows
+ ncols:
+ type: integer
+ description: number of subplot columns
+ time_max:
+ type: number
+ format: double
+ minimum: 0
+ description: maximum time for the simulation
+ abs_tolerance:
+ type: number
+ format: double
+ minimum: 0
+ description: absolute tolerance for the simulation
+ rel_tolerance:
+ type: number
+ format: double
+ minimum: 0
+ description: relative tolerance for the simulation
+ project:
+ type: integer
+ time_max_unit:
+ type: integer
+ description: unit for maximum time
+ required:
+ - id
+ - name
+ - plots
+ - project
+ - sliders
+ - time_max_unit
+ SimulationCxLine:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ value:
+ type: number
+ format: double
+ description: value of the line
+ required:
+ - id
+ - value
+ SimulationPlot:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ y_axes:
+ type: array
+ items:
+ $ref: '#/components/schemas/SimulationYAxis'
+ cx_lines:
+ type: array
+ items:
+ $ref: '#/components/schemas/SimulationCxLine'
+ index:
+ type: integer
+ description: index of the plot in the simulation
+ x_scale:
+ allOf:
+ - $ref: '#/components/schemas/Y2ScaleEnum'
+ description: |-
+ scale for x axis
+
+ * `lin` - Linear
+ * `lg2` - Log2
+ * `lg10` - Log10
+ * `ln` - Ln
+ y_scale:
+ allOf:
+ - $ref: '#/components/schemas/Y2ScaleEnum'
+ description: |-
+ scale for y axis
+
+ * `lin` - Linear
+ * `lg2` - Log2
+ * `lg10` - Log10
+ * `ln` - Ln
+ y2_scale:
+ allOf:
+ - $ref: '#/components/schemas/Y2ScaleEnum'
+ description: |-
+ scale for rhs y axis
+
+ * `lin` - Linear
+ * `lg2` - Log2
+ * `lg10` - Log10
+ * `ln` - Ln
+ min:
+ type: number
+ format: double
+ nullable: true
+ description: lower bound for the y axis
+ max:
+ type: number
+ format: double
+ nullable: true
+ description: upper bound for the y axis
+ min2:
+ type: number
+ format: double
+ nullable: true
+ description: lower bound for the rhs y axis
+ max2:
+ type: number
+ format: double
+ nullable: true
+ description: upper bound for the rhs y axis
+ x_unit:
+ type: integer
+ description: unit for x axis
+ y_unit:
+ type: integer
+ nullable: true
+ description: unit for y axis
+ y_unit2:
+ type: integer
+ nullable: true
+ description: unit for rhs y axis
+ required:
+ - cx_lines
+ - id
+ - index
+ - x_unit
+ - y_axes
+ SimulationSlider:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ variable:
+ type: integer
+ required:
+ - id
+ - variable
+ SimulationYAxis:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ right:
+ type: boolean
+ description: True if the variable is plotted on the right y axis
+ variable:
+ type: integer
+ required:
+ - id
+ - variable
+ Subject:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ id_in_dataset:
+ type: integer
+ description: unique id in the dataset
+ shape:
+ type: integer
+ description: Shape index associated with this subject. For plotting purposes
+ in the frontend
+ display:
+ type: boolean
+ description: True if this subject will be displayed in the frontend, False
+ otherwise
+ metadata:
+ type: string
+ description: subject metadata
+ dataset:
+ type: integer
+ description: dataset containing this subject
+ protocol:
+ type: integer
+ nullable: true
+ description: dosing protocol for this subject.
+ required:
+ - dataset
+ - id
+ - id_in_dataset
+ TypeEnum:
+ enum:
+ - RO
+ - FUP
+ - BPR
+ - TLG
+ type: string
+ description: |-
+ * `RO` - receptor occupancy
+ * `FUP` - faction unbound plasma
+ * `BPR` - blood plasma ratio
+ * `TLG` - dosing lag time
+ Unit:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ compatible_units:
+ type: array
+ items:
+ type: object
+ additionalProperties:
+ type: string
+ readOnly: true
+ symbol:
+ type: string
+ description: symbol for unit display
+ maxLength: 50
+ g:
+ type: number
+ format: double
+ description: grams exponent
+ m:
+ type: number
+ format: double
+ description: meters exponent
+ s:
+ type: number
+ format: double
+ description: seconds exponent
+ A:
+ type: number
+ format: double
+ description: ampere exponent
+ K:
+ type: number
+ format: double
+ description: kelvin exponent
+ cd:
+ type: number
+ format: double
+ description: candela exponent
+ mol:
+ type: number
+ format: double
+ description: mole exponent
+ multiplier:
+ type: number
+ format: double
+ description: multiplier in powers of 10
+ required:
+ - compatible_units
+ - id
+ - symbol
+ User:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ username:
+ type: string
+ description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
+ only.
+ pattern: ^[\w.@+-]+$
+ maxLength: 150
+ first_name:
+ type: string
+ maxLength: 150
+ last_name:
+ type: string
+ maxLength: 150
+ email:
+ type: string
+ format: email
+ title: Email address
+ maxLength: 254
+ profile:
+ allOf:
+ - $ref: '#/components/schemas/Profile'
+ readOnly: true
+ project_set:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ required:
+ - id
+ - profile
+ - project_set
+ - username
+ Variable:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ is_public:
+ type: boolean
+ lower_bound:
+ type: number
+ format: double
+ nullable: true
+ description: lowest possible value for this variable
+ upper_bound:
+ type: number
+ format: double
+ nullable: true
+ description: largest possible value for this variable
+ default_value:
+ type: number
+ format: double
+ description: default value for this variable
+ is_log:
+ type: boolean
+ description: True if default_value is stored as the log of this value
+ name:
+ type: string
+ description: name of the variable
+ maxLength: 100
+ description:
+ type: string
+ nullable: true
+ description: description of the variable
+ binding:
+ type: string
+ nullable: true
+ description: myokit binding of the variable (e.g. time)
+ maxLength: 100
+ qname:
+ type: string
+ description: fully qualitifed name of the variable
+ maxLength: 200
+ unit_symbol:
+ type: string
+ nullable: true
+ description: if unit is None then this is the unit of this variable as a
+ string
+ maxLength: 20
+ constant:
+ type: boolean
+ description: True for a constant variable of the model, i.e. a parameter.
+ False if non-constant, i.e. an output of the model (default is True)
+ state:
+ type: boolean
+ description: True if it is a state variable of the model and has an initial
+ condition parameter (default is False)
+ color:
+ type: integer
+ description: Color index associated with this variable. For display purposes
+ in the frontend
+ display:
+ type: boolean
+ description: True if this variable will be displayed in the frontend, False
+ otherwise
+ axis:
+ type: boolean
+ description: False/True if biomarker type displayed on LHS/RHS axis
+ unit:
+ type: integer
+ nullable: true
+ description: variable values are in this unit (note this might be different
+ from the unit in the stored sbml)
+ pd_model:
+ type: integer
+ nullable: true
+ description: pharmacodynamic model
+ pk_model:
+ type: integer
+ nullable: true
+ description: pharmacokinetic model
+ dosed_pk_model:
+ type: integer
+ nullable: true
+ description: dosed pharmacokinetic model
+ protocol:
+ type: integer
+ nullable: true
+ description: dosing protocol
+ required:
+ - id
+ - name
+ - qname
+ Y2ScaleEnum:
+ enum:
+ - lin
+ - lg2
+ - lg10
+ - ln
+ type: string
+ description: |-
+ * `lin` - Linear
+ * `lg2` - Log2
+ * `lg10` - Log10
+ * `ln` - Ln
+ securitySchemes:
+ basicAuth:
+ type: http
+ scheme: basic
+ cookieAuth:
+ type: apiKey
+ in: cookie
+ name: sessionid
diff --git a/pkpdapp/schema.yml# b/pkpdapp/schema.yml#
new file mode 100644
index 00000000..6c37d1ca
--- /dev/null
+++ b/pkpdapp/schema.yml#
@@ -0,0 +1,4584 @@
+openapi: 3.0.3
+info:
+ title: PKPDApp API
+ version: 1.0.0
+ description: The API for the PKPDApp
+paths:
+ /api/algorithm/:
+ get:
+ operationId: algorithm_list
+ tags:
+ - algorithm
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ post:
+ operationId: algorithm_create
+ tags:
+ - algorithm
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ /api/algorithm/{id}/:
+ get:
+ operationId: algorithm_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this algorithm.
+ required: true
+ tags:
+ - algorithm
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ put:
+ operationId: algorithm_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this algorithm.
+ required: true
+ tags:
+ - algorithm
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ patch:
+ operationId: algorithm_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this algorithm.
+ required: true
+ tags:
+ - algorithm
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedAlgorithm'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedAlgorithm'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedAlgorithm'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Algorithm'
+ description: ''
+ delete:
+ operationId: algorithm_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this algorithm.
+ required: true
+ tags:
+ - algorithm
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/auce/:
+ post:
+ operationId: auce_create
+ tags:
+ - auce
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/biomarker_type/:
+ get:
+ operationId: biomarker_type_list
+ tags:
+ - biomarker_type
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ post:
+ operationId: biomarker_type_create
+ tags:
+ - biomarker_type
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ /api/biomarker_type/{id}/:
+ get:
+ operationId: biomarker_type_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this biomarker type.
+ required: true
+ tags:
+ - biomarker_type
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ put:
+ operationId: biomarker_type_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this biomarker type.
+ required: true
+ tags:
+ - biomarker_type
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ patch:
+ operationId: biomarker_type_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this biomarker type.
+ required: true
+ tags:
+ - biomarker_type
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedBiomarkerType'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedBiomarkerType'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedBiomarkerType'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/BiomarkerType'
+ description: ''
+ delete:
+ operationId: biomarker_type_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this biomarker type.
+ required: true
+ tags:
+ - biomarker_type
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/compound/:
+ get:
+ operationId: compound_list
+ tags:
+ - compound
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ post:
+ operationId: compound_create
+ tags:
+ - compound
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ /api/compound/{id}/:
+ get:
+ operationId: compound_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this compound.
+ required: true
+ tags:
+ - compound
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ put:
+ operationId: compound_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this compound.
+ required: true
+ tags:
+ - compound
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ patch:
+ operationId: compound_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this compound.
+ required: true
+ tags:
+ - compound
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedCompound'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedCompound'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedCompound'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Compound'
+ description: ''
+ delete:
+ operationId: compound_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this compound.
+ required: true
+ tags:
+ - compound
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/dataset/:
+ get:
+ operationId: dataset_list
+ tags:
+ - dataset
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ post:
+ operationId: dataset_create
+ tags:
+ - dataset
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ /api/dataset/{id}/:
+ get:
+ operationId: dataset_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ put:
+ operationId: dataset_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ patch:
+ operationId: dataset_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedDataset'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedDataset'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedDataset'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dataset'
+ description: ''
+ delete:
+ operationId: dataset_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/dataset/{id}/csv/:
+ put:
+ operationId: dataset_csv_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dataset.
+ required: true
+ tags:
+ - dataset
+ requestBody:
+ content:
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/DatasetCsv'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DatasetCsv'
+ description: ''
+ /api/dose/:
+ get:
+ operationId: dose_list
+ tags:
+ - dose
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ post:
+ operationId: dose_create
+ tags:
+ - dose
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ /api/dose/{id}/:
+ get:
+ operationId: dose_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dose.
+ required: true
+ tags:
+ - dose
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ put:
+ operationId: dose_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dose.
+ required: true
+ tags:
+ - dose
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ patch:
+ operationId: dose_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dose.
+ required: true
+ tags:
+ - dose
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedDose'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedDose'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedDose'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Dose'
+ description: ''
+ delete:
+ operationId: dose_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dose.
+ required: true
+ tags:
+ - dose
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/dosed_pharmacokinetic/:
+ get:
+ operationId: dosed_pharmacokinetic_list
+ tags:
+ - dosed_pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ description: ''
+ post:
+ operationId: dosed_pharmacokinetic_create
+ tags:
+ - dosed_pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ description: ''
+ /api/dosed_pharmacokinetic/{id}/:
+ get:
+ operationId: dosed_pharmacokinetic_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dosed pharmacokinetic
+ model.
+ required: true
+ tags:
+ - dosed_pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ description: ''
+ put:
+ operationId: dosed_pharmacokinetic_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dosed pharmacokinetic
+ model.
+ required: true
+ tags:
+ - dosed_pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ description: ''
+ patch:
+ operationId: dosed_pharmacokinetic_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dosed pharmacokinetic
+ model.
+ required: true
+ tags:
+ - dosed_pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedDosedPharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedDosedPharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedDosedPharmacokinetic'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ description: ''
+ delete:
+ operationId: dosed_pharmacokinetic_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dosed pharmacokinetic
+ model.
+ required: true
+ tags:
+ - dosed_pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/dosed_pharmacokinetic/{id}/set_variables_from_inference/:
+ put:
+ operationId: dosed_pharmacokinetic_set_variables_from_inference_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this dosed pharmacokinetic
+ model.
+ required: true
+ tags:
+ - dosed_pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/DosedPharmacokinetic'
+ description: ''
+ /api/dosed_pharmacokinetic/{id}/simulate:
+ post:
+ operationId: dosed_pharmacokinetic_simulate_create
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ required: true
+ tags:
+ - dosed_pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/inference/:
+ get:
+ operationId: inference_list
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ post:
+ operationId: inference_create
+ tags:
+ - inference
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ /api/inference/{id}/:
+ get:
+ operationId: inference_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference.
+ required: true
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ put:
+ operationId: inference_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference.
+ required: true
+ tags:
+ - inference
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ patch:
+ operationId: inference_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference.
+ required: true
+ tags:
+ - inference
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedInference'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedInference'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedInference'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Inference'
+ description: ''
+ delete:
+ operationId: inference_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference.
+ required: true
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/inference/{id}/stop:
+ post:
+ operationId: inference_stop_create
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ required: true
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/inference/wizard:
+ post:
+ operationId: inference_wizard_create
+ description: |-
+ expecting data in the form:
+ {
+
+ # Inference parameters
+ 'id': 1
+ 'name': "my inference run",
+ 'project': 1,
+ 'algorithm': 2,
+ 'initialization_strategy': 'R',
+ 'initialization_inference': 2,
+ 'number_of_chains': 4,
+ 'max_number_of_iterations': 3000,
+ 'burn_in': 0,
+
+ # Model
+ 'model': {
+ 'form': 'PK',
+ 'id': 5
+ }
+ 'dataset': 3,
+
+ # Model parameters
+ 'parameters': [
+ {
+ 'name': 'myokit.parameter1'
+ 'form': 'N',
+ 'pooled': False,
+ 'parameters': [
+ '2 * biomarker[subject_weight]',
+ 'parameter[parameter1_variance]'
+ ]
+ },
+ {
+ 'name': 'parameter1_variance'
+ 'form': 'N',
+ 'parameters': [0, 1]
+ },
+ {
+ 'name': 'myokit.parameter2'
+ 'form': 'U',
+ 'parameters': [-1, 1]
+ },
+ {
+ 'name': 'myokit.parameter3'
+ 'form': 'F',
+ 'parameters': [123.5]
+ },
+ ]
+
+ # output
+ 'observations': [
+ {
+ 'model': 'myokit.plasma_concentration',
+ 'biomarker': 'concentration,
+ 'noise_form': 'N',
+ 'noise_param_form': 'N',
+ 'parameters': [0, 1]
+ },
+ {
+ 'model': 'myokit.bacteria_count',
+ 'biomarker': 'bacteria,
+ 'noise_form': 'LN',
+ 'noise_param_form': 'F'
+ 'parameters': [123.3]
+ },
+ ]
+ }
+
+ Uses model as the base model. If it is a PK or PKPD model, creates a model
+ for each protocol used in the dataset, replacing the protocol of the model
+ with each new one.
+
+ This set of models has a set of parameters. If pooled is True or not given,
+ then parameters of the same qname are assumed to be identical, if pooled is
+ False, then the value of this parameter is different across each subject.
+ All Variable fields from the original model are copied over to the new
+ models. Priors and fixed values for each parameter in this set are provided
+ in 'parameters'. Distribution parameters for each prior can be provided
+ using a python expression, or a number. If a python expression is used, the
+ keywords Parameter[] are used to refer to other parameters in
+ the list. Additional parameters can be added to the list (parameters not in
+ the model) to contruct hierarchical inference. You can refer to biomarkers
+ in the expression using the keyword Biomarker[].
+
+ The 'observations' field maps model output variables with biomarkers in the
+ dataset
+ tags:
+ - inference
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/inference_chain/:
+ get:
+ operationId: inference_chain_list
+ tags:
+ - inference_chain
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ post:
+ operationId: inference_chain_create
+ tags:
+ - inference_chain
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ /api/inference_chain/{id}/:
+ get:
+ operationId: inference_chain_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference chain.
+ required: true
+ tags:
+ - inference_chain
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ put:
+ operationId: inference_chain_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference chain.
+ required: true
+ tags:
+ - inference_chain
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ patch:
+ operationId: inference_chain_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference chain.
+ required: true
+ tags:
+ - inference_chain
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedInferenceChain'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedInferenceChain'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedInferenceChain'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/InferenceChain'
+ description: ''
+ delete:
+ operationId: inference_chain_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this inference chain.
+ required: true
+ tags:
+ - inference_chain
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/nca/:
+ post:
+ operationId: nca_create
+ tags:
+ - nca
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/pharmacodynamic/:
+ get:
+ operationId: pharmacodynamic_list
+ tags:
+ - pharmacodynamic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ post:
+ operationId: pharmacodynamic_create
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ /api/pharmacodynamic/{id}/:
+ get:
+ operationId: pharmacodynamic_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ put:
+ operationId: pharmacodynamic_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ patch:
+ operationId: pharmacodynamic_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacodynamic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacodynamic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacodynamic'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ delete:
+ operationId: pharmacodynamic_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/pharmacodynamic/{id}/mmt/:
+ put:
+ operationId: pharmacodynamic_mmt_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ /api/pharmacodynamic/{id}/sbml/:
+ put:
+ operationId: pharmacodynamic_sbml_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PharmacodynamicSbml'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PharmacodynamicSbml'
+ description: ''
+ /api/pharmacodynamic/{id}/set_variables_from_inference/:
+ put:
+ operationId: pharmacodynamic_set_variables_from_inference_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacodynamic model.
+ required: true
+ tags:
+ - pharmacodynamic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacodynamic'
+ description: ''
+ /api/pharmacodynamic/{id}/simulate:
+ post:
+ operationId: pharmacodynamic_simulate_create
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ required: true
+ tags:
+ - pharmacodynamic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/pharmacokinetic/:
+ get:
+ operationId: pharmacokinetic_list
+ tags:
+ - pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ post:
+ operationId: pharmacokinetic_create
+ tags:
+ - pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ /api/pharmacokinetic/{id}/:
+ get:
+ operationId: pharmacokinetic_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacokinetic model.
+ required: true
+ tags:
+ - pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ put:
+ operationId: pharmacokinetic_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacokinetic model.
+ required: true
+ tags:
+ - pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ patch:
+ operationId: pharmacokinetic_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacokinetic model.
+ required: true
+ tags:
+ - pharmacokinetic
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacokinetic'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacokinetic'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedPharmacokinetic'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Pharmacokinetic'
+ description: ''
+ delete:
+ operationId: pharmacokinetic_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this pharmacokinetic model.
+ required: true
+ tags:
+ - pharmacokinetic
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/project/:
+ get:
+ operationId: project_list
+ description: Enable partial updates
+ tags:
+ - project
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ post:
+ operationId: project_create
+ description: Enable partial updates
+ tags:
+ - project
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Project'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Project'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ /api/project/{id}/:
+ get:
+ operationId: project_retrieve
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ put:
+ operationId: project_update
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Project'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Project'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ patch:
+ operationId: project_partial_update
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedProject'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedProject'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedProject'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Project'
+ description: ''
+ delete:
+ operationId: project_destroy
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/project/{id}/monolix/:
+ put:
+ operationId: project_monolix_update
+ description: Enable partial updates
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project.
+ required: true
+ tags:
+ - project
+ requestBody:
+ content:
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Monolix'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Monolix'
+ description: ''
+ /api/project_access/:
+ get:
+ operationId: project_access_list
+ tags:
+ - project_access
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ post:
+ operationId: project_access_create
+ tags:
+ - project_access
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ /api/project_access/{id}/:
+ get:
+ operationId: project_access_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project access.
+ required: true
+ tags:
+ - project_access
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ put:
+ operationId: project_access_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project access.
+ required: true
+ tags:
+ - project_access
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ patch:
+ operationId: project_access_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project access.
+ required: true
+ tags:
+ - project_access
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedProjectAccess'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedProjectAccess'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedProjectAccess'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/ProjectAccess'
+ description: ''
+ delete:
+ operationId: project_access_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this project access.
+ required: true
+ tags:
+ - project_access
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/protocol/:
+ get:
+ operationId: protocol_list
+ tags:
+ - protocol
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ post:
+ operationId: protocol_create
+ tags:
+ - protocol
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ /api/protocol/{id}/:
+ get:
+ operationId: protocol_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this protocol.
+ required: true
+ tags:
+ - protocol
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ put:
+ operationId: protocol_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this protocol.
+ required: true
+ tags:
+ - protocol
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ patch:
+ operationId: protocol_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this protocol.
+ required: true
+ tags:
+ - protocol
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedProtocol'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedProtocol'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedProtocol'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Protocol'
+ description: ''
+ delete:
+ operationId: protocol_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this protocol.
+ required: true
+ tags:
+ - protocol
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/session/:
+ get:
+ operationId: session_retrieve
+ tags:
+ - session
+ security:
+ - cookieAuth: []
+ - basicAuth: []
+ responses:
+ '200':
+ description: No response body
+ /api/subject/:
+ get:
+ operationId: subject_list
+ tags:
+ - subject
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ post:
+ operationId: subject_create
+ tags:
+ - subject
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ /api/subject/{id}/:
+ get:
+ operationId: subject_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this subject.
+ required: true
+ tags:
+ - subject
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ put:
+ operationId: subject_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this subject.
+ required: true
+ tags:
+ - subject
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ patch:
+ operationId: subject_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this subject.
+ required: true
+ tags:
+ - subject
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedSubject'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedSubject'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedSubject'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Subject'
+ description: ''
+ delete:
+ operationId: subject_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this subject.
+ required: true
+ tags:
+ - subject
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/unit/:
+ get:
+ operationId: unit_list
+ tags:
+ - unit
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ post:
+ operationId: unit_create
+ tags:
+ - unit
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ /api/unit/{id}/:
+ get:
+ operationId: unit_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this unit.
+ required: true
+ tags:
+ - unit
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ put:
+ operationId: unit_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this unit.
+ required: true
+ tags:
+ - unit
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ patch:
+ operationId: unit_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this unit.
+ required: true
+ tags:
+ - unit
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedUnit'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedUnit'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedUnit'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Unit'
+ description: ''
+ delete:
+ operationId: unit_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this unit.
+ required: true
+ tags:
+ - unit
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/user/:
+ get:
+ operationId: user_list
+ tags:
+ - user
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/User'
+ description: ''
+ post:
+ operationId: user_create
+ tags:
+ - user
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/User'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/User'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ description: ''
+ /api/user/{id}/:
+ get:
+ operationId: user_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this user.
+ required: true
+ tags:
+ - user
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ description: ''
+ put:
+ operationId: user_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this user.
+ required: true
+ tags:
+ - user
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/User'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/User'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ description: ''
+ patch:
+ operationId: user_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this user.
+ required: true
+ tags:
+ - user
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedUser'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedUser'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedUser'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/User'
+ description: ''
+ delete:
+ operationId: user_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this user.
+ required: true
+ tags:
+ - user
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/variable/:
+ get:
+ operationId: variable_list
+ tags:
+ - variable
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ post:
+ operationId: variable_create
+ tags:
+ - variable
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '201':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ /api/variable/{id}/:
+ get:
+ operationId: variable_retrieve
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this variable.
+ required: true
+ tags:
+ - variable
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ put:
+ operationId: variable_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this variable.
+ required: true
+ tags:
+ - variable
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ required: true
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ patch:
+ operationId: variable_partial_update
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this variable.
+ required: true
+ tags:
+ - variable
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/PatchedVariable'
+ application/x-www-form-urlencoded:
+ schema:
+ $ref: '#/components/schemas/PatchedVariable'
+ multipart/form-data:
+ schema:
+ $ref: '#/components/schemas/PatchedVariable'
+ security:
+ - cookieAuth: []
+ responses:
+ '200':
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Variable'
+ description: ''
+ delete:
+ operationId: variable_destroy
+ parameters:
+ - in: path
+ name: id
+ schema:
+ type: integer
+ description: A unique integer value identifying this variable.
+ required: true
+ tags:
+ - variable
+ security:
+ - cookieAuth: []
+ responses:
+ '204':
+ description: No response body
+ /api/whoami/:
+ get:
+ operationId: whoami_retrieve
+ tags:
+ - whoami
+ security:
+ - cookieAuth: []
+ - basicAuth: []
+ responses:
+ '200':
+ description: No response body
+components:
+ schemas:
+ Algorithm:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of the algorithm
+ maxLength: 100
+ category:
+ $ref: '#/components/schemas/CategoryEnum'
+ required:
+ - category
+ - id
+ - name
+ BiomarkerType:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ data:
+ type: object
+ additionalProperties:
+ type: array
+ items: {}
+ nullable: true
+ readOnly: true
+ is_continuous:
+ type: boolean
+ readOnly: true
+ is_categorical:
+ type: boolean
+ readOnly: true
+ name:
+ type: string
+ description: name of the biomarker type
+ maxLength: 100
+ description:
+ type: string
+ nullable: true
+ description: short description of the biomarker type
+ display:
+ type: boolean
+ description: True if this biomarker type will be displayed in the frontend,
+ False otherwise
+ color:
+ type: integer
+ description: Color index associated with this biomarker type. For plotting
+ purposes in the frontend
+ axis:
+ type: boolean
+ description: True/False if biomarker type displayed on LHS/RHS axis
+ stored_unit:
+ type: integer
+ description: unit for the value stored in :model:`pkpdapp.Biomarker`
+ dataset:
+ type: integer
+ description: dataset containing this biomarker measurement
+ display_unit:
+ type: integer
+ description: unit to use when sending or displaying biomarker values
+ stored_time_unit:
+ type: integer
+ description: unit for the time values stored in :model:`pkpdapp.Biomarker`
+ display_time_unit:
+ type: integer
+ description: unit to use when sending or displaying time values
+ required:
+ - data
+ - dataset
+ - display_time_unit
+ - display_unit
+ - id
+ - is_categorical
+ - is_continuous
+ - name
+ - stored_time_unit
+ - stored_unit
+ CategoryEnum:
+ enum:
+ - SA
+ - OP
+ - OT
+ type: string
+ description: |-
+ * `SA` - Sampling
+ * `OP` - Optimisation
+ * `OT` - Optimisation
+ Compound:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ efficacy_experiments:
+ type: array
+ items:
+ $ref: '#/components/schemas/Efficacy'
+ name:
+ type: string
+ description: name of the compound
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the compound
+ molecular_mass:
+ type: number
+ format: double
+ description: molecular mass for compound for conversion from mol to grams
+ compound_type:
+ $ref: '#/components/schemas/CompoundTypeEnum'
+ fraction_unbound_plasma:
+ type: number
+ format: double
+ nullable: true
+ description: fraction unbound plasma (unitless)
+ blood_to_plasma_ratio:
+ type: number
+ format: double
+ nullable: true
+ description: blood to plasma ratio (unitless)
+ intrinsic_clearence:
+ type: number
+ format: double
+ nullable: true
+ description: intrinsic clearance
+ intrinsic_clearence_assay:
+ $ref: '#/components/schemas/IntrinsicClearenceAssayEnum'
+ fraction_unbound_including_cells:
+ type: number
+ format: double
+ nullable: true
+ description: fraction unbound in plasma and red blood cells (unitless)
+ target_concentration:
+ type: number
+ format: double
+ nullable: true
+ description: target concentration
+ dissociation_constant:
+ type: number
+ format: double
+ nullable: true
+ description: dissociation constant
+ calculate_receptor_occupancy:
+ type: boolean
+ description: calculate receptor occupancy
+ is_soluble:
+ type: boolean
+ description: is the compound target soluble
+ molecular_mass_unit:
+ type: integer
+ description: unit for molecular mass (e.g. g/mol)
+ intrinsic_clearence_unit:
+ type: integer
+ description: unit for intrinsic clearance
+ target_concentration_unit:
+ type: integer
+ description: unit for target concentration
+ dissociation_unit:
+ type: integer
+ description: unit for dissociation constant
+ required:
+ - efficacy_experiments
+ - id
+ - molecular_mass
+ - name
+ CompoundTypeEnum:
+ enum:
+ - SM
+ - LM
+ type: string
+ description: |-
+ * `SM` - Small Molecule
+ * `LM` - Large Molecule
+ Dataset:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ biomarker_types:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ subjects:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ protocols:
+ type: array
+ items:
+ $ref: '#/components/schemas/Protocol'
+ readOnly: true
+ name:
+ type: string
+ description: name of the dataset
+ maxLength: 100
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: date/time the experiment was conducted. All time measurements
+ are relative to this date/time, which is in YYYY-MM-DD HH:MM:SS format.
+ For example, 2020-07-18 14:30:59
+ description:
+ type: string
+ description: short description of the dataset
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ required:
+ - biomarker_types
+ - id
+ - name
+ - protocols
+ - subjects
+ DatasetCsv:
+ type: object
+ properties:
+ csv:
+ type: string
+ format: uri
+ required:
+ - csv
+ Dose:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ start_time:
+ type: number
+ format: double
+ description: starting time point of dose, see protocol for units
+ amount:
+ type: number
+ format: double
+ description: amount of compound administered over the duration, see protocol
+ for units. Rate of administration is assumed constant
+ duration:
+ type: number
+ format: double
+ description: Duration of dose administration, see protocol for units. Duration
+ must be greater than 0.
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ protocol:
+ type: integer
+ description: protocol containing this dose
+ required:
+ - amount
+ - id
+ - protocol
+ - start_time
+ DoseTypeEnum:
+ enum:
+ - D
+ - I
+ type: string
+ description: |-
+ * `D` - IV
+ * `I` - Extravascular
+ DosedPharmacokinetic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ mappings:
+ type: array
+ items:
+ $ref: '#/components/schemas/PkpdMapping'
+ components:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ mmt:
+ type: string
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ dose_compartment:
+ type: string
+ nullable: true
+ description: compartment name to be dosed
+ maxLength: 100
+ time_max:
+ type: number
+ format: double
+ description: suggested time to simulate after the last dose (in the time
+ units specified by the mmt model)
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ pk_model:
+ type: integer
+ nullable: true
+ description: model
+ pd_model:
+ type: integer
+ nullable: true
+ description: PD part of model
+ protocol:
+ type: integer
+ nullable: true
+ description: dosing protocol
+ required:
+ - components
+ - id
+ - mappings
+ - mmt
+ - name
+ - variables
+ Efficacy:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of the experiment
+ maxLength: 100
+ c50:
+ type: number
+ format: double
+ description: half maximal effective concentration
+ hill_coefficient:
+ type: number
+ format: double
+ description: Hill coefficient measure of binding
+ c50_unit:
+ type: integer
+ description: unit for c50
+ compound:
+ type: integer
+ description: compound for efficacy experiment
+ required:
+ - c50
+ - c50_unit
+ - compound
+ - id
+ - name
+ FormEnum:
+ enum:
+ - N
+ - U
+ - LN
+ - F
+ - S
+ - E
+ - M
+ type: string
+ description: |-
+ * `N` - Normal
+ * `U` - Uniform
+ * `LN` - Log-Normal
+ * `F` - Fixed
+ * `S` - Sum
+ * `E` - Equation
+ * `M` - Model
+ Inference:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ log_likelihoods:
+ type: array
+ items:
+ $ref: '#/components/schemas/LogLikelihood'
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the dataset
+ maxLength: 100
+ description:
+ type: string
+ description: short description of what this inference does
+ initialization_strategy:
+ $ref: '#/components/schemas/InitializationStrategyEnum'
+ number_of_chains:
+ type: integer
+ description: number of chains
+ max_number_of_iterations:
+ type: integer
+ description: maximum number of iterations
+ burn_in:
+ type: integer
+ description: final iteration of burn-in
+ number_of_iterations:
+ type: integer
+ description: number of iterations calculated
+ time_elapsed:
+ type: integer
+ description: Elapsed run time for inference in seconds
+ number_of_function_evals:
+ type: integer
+ description: number of function evaluations
+ task_id:
+ type: string
+ nullable: true
+ description: If executing, this is the celery task id
+ maxLength: 40
+ metadata:
+ type: object
+ additionalProperties: {}
+ description: metadata for inference
+ project:
+ type: integer
+ description: Project that "owns" this inference object
+ algorithm:
+ type: integer
+ description: algorithm used to perform the inference
+ initialization_inference:
+ type: integer
+ nullable: true
+ required:
+ - id
+ - log_likelihoods
+ - name
+ - project
+ InferenceChain:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ data:
+ type: string
+ readOnly: true
+ outputs:
+ type: string
+ readOnly: true
+ inference:
+ type: integer
+ description: inference for this chain
+ required:
+ - data
+ - id
+ - inference
+ - outputs
+ InitializationStrategyEnum:
+ enum:
+ - D
+ - R
+ - F
+ type: string
+ description: |-
+ * `D` - Default Value of model
+ * `R` - Random from prior
+ * `F` - From other inference
+ IntrinsicClearenceAssayEnum:
+ enum:
+ - MS
+ - HC
+ type: string
+ description: |-
+ * `MS` - Microsomes
+ * `HC` - Hepatocytes
+ LogLikelihood:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ parameters:
+ type: array
+ items:
+ $ref: '#/components/schemas/LogLikelihoodParameter'
+ model:
+ type: array
+ items:
+ type: string
+ minLength: 2
+ maxLength: 2
+ nullable: true
+ readOnly: true
+ dataset:
+ type: integer
+ nullable: true
+ readOnly: true
+ time_variable:
+ type: integer
+ nullable: true
+ readOnly: true
+ is_a_prior:
+ type: boolean
+ readOnly: true
+ name:
+ type: string
+ description: name of log_likelihood.
+ maxLength: 100
+ description:
+ type: string
+ nullable: true
+ description: 'description of log_likelihood. For equations will be the code
+ of that equation using Python syntax: arg1 * arg2^arg3'
+ value:
+ type: number
+ format: double
+ nullable: true
+ description: set if a fixed value is required
+ time_independent_data:
+ type: boolean
+ description: 'True if biomarker_type refers to time-independent data. If
+ there are multiple timepoints in biomarker_type then only the first is
+ taken '
+ observed:
+ type: boolean
+ description: 'True if this log_likelihood is observed '
+ form:
+ $ref: '#/components/schemas/FormEnum'
+ inference:
+ type: integer
+ readOnly: true
+ description: 'Log_likelihood belongs to this inference object. '
+ variable:
+ type: integer
+ nullable: true
+ description: 'If form=MODEL, a variable (any) in the deterministic model. '
+ biomarker_type:
+ type: integer
+ nullable: true
+ description: data associated with this log_likelihood. This is used for
+ measurement data (observed=True) or for covariates (observed=False). The
+ random variable associated with this log_likelihood has the same shape
+ as this data. For covariates the subject ids in the data correspond to
+ the values of the random variable at that location.
+ protocol_filter:
+ type: integer
+ nullable: true
+ description: filter subject data on this protocol(null implies all subjects)
+ children:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ required:
+ - children
+ - dataset
+ - id
+ - inference
+ - is_a_prior
+ - model
+ - name
+ - parameters
+ - time_variable
+ LogLikelihoodParameter:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of log_likelihood parameter.
+ maxLength: 100
+ parent_index:
+ type: integer
+ nullable: true
+ description: parameter index for distribution and equation parameters. blank
+ for models (variable is used instead)
+ child_index:
+ type: integer
+ description: 'output index for all log_likelihoods. '
+ length:
+ type: integer
+ nullable: true
+ description: length of array representing parameter. null for scalar
+ parent:
+ type: integer
+ readOnly: true
+ child:
+ type: integer
+ variable:
+ type: integer
+ nullable: true
+ description: input model variable for this parameter.
+ required:
+ - child
+ - id
+ - name
+ - parent
+ Monolix:
+ type: object
+ properties:
+ data_csv:
+ type: string
+ format: uri
+ writeOnly: true
+ model_txt:
+ type: string
+ format: uri
+ writeOnly: true
+ project_mlxtran:
+ type: string
+ format: uri
+ writeOnly: true
+ data:
+ type: string
+ readOnly: true
+ pd_model:
+ type: string
+ readOnly: true
+ pk_model:
+ type: string
+ readOnly: true
+ required:
+ - data
+ - data_csv
+ - model_txt
+ - pd_model
+ - pk_model
+ - project_mlxtran
+ PatchedAlgorithm:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ name:
+ type: string
+ description: name of the algorithm
+ maxLength: 100
+ category:
+ $ref: '#/components/schemas/CategoryEnum'
+ PatchedBiomarkerType:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ data:
+ type: object
+ additionalProperties:
+ type: array
+ items: {}
+ nullable: true
+ readOnly: true
+ is_continuous:
+ type: boolean
+ readOnly: true
+ is_categorical:
+ type: boolean
+ readOnly: true
+ name:
+ type: string
+ description: name of the biomarker type
+ maxLength: 100
+ description:
+ type: string
+ nullable: true
+ description: short description of the biomarker type
+ display:
+ type: boolean
+ description: True if this biomarker type will be displayed in the frontend,
+ False otherwise
+ color:
+ type: integer
+ description: Color index associated with this biomarker type. For plotting
+ purposes in the frontend
+ axis:
+ type: boolean
+ description: True/False if biomarker type displayed on LHS/RHS axis
+ stored_unit:
+ type: integer
+ description: unit for the value stored in :model:`pkpdapp.Biomarker`
+ dataset:
+ type: integer
+ description: dataset containing this biomarker measurement
+ display_unit:
+ type: integer
+ description: unit to use when sending or displaying biomarker values
+ stored_time_unit:
+ type: integer
+ description: unit for the time values stored in :model:`pkpdapp.Biomarker`
+ display_time_unit:
+ type: integer
+ description: unit to use when sending or displaying time values
+ PatchedCompound:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ efficacy_experiments:
+ type: array
+ items:
+ $ref: '#/components/schemas/Efficacy'
+ name:
+ type: string
+ description: name of the compound
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the compound
+ molecular_mass:
+ type: number
+ format: double
+ description: molecular mass for compound for conversion from mol to grams
+ compound_type:
+ $ref: '#/components/schemas/CompoundTypeEnum'
+ fraction_unbound_plasma:
+ type: number
+ format: double
+ nullable: true
+ description: fraction unbound plasma (unitless)
+ blood_to_plasma_ratio:
+ type: number
+ format: double
+ nullable: true
+ description: blood to plasma ratio (unitless)
+ intrinsic_clearence:
+ type: number
+ format: double
+ nullable: true
+ description: intrinsic clearance
+ intrinsic_clearence_assay:
+ $ref: '#/components/schemas/IntrinsicClearenceAssayEnum'
+ fraction_unbound_including_cells:
+ type: number
+ format: double
+ nullable: true
+ description: fraction unbound in plasma and red blood cells (unitless)
+ target_concentration:
+ type: number
+ format: double
+ nullable: true
+ description: target concentration
+ dissociation_constant:
+ type: number
+ format: double
+ nullable: true
+ description: dissociation constant
+ calculate_receptor_occupancy:
+ type: boolean
+ description: calculate receptor occupancy
+ is_soluble:
+ type: boolean
+ description: is the compound target soluble
+ molecular_mass_unit:
+ type: integer
+ description: unit for molecular mass (e.g. g/mol)
+ intrinsic_clearence_unit:
+ type: integer
+ description: unit for intrinsic clearance
+ target_concentration_unit:
+ type: integer
+ description: unit for target concentration
+ dissociation_unit:
+ type: integer
+ description: unit for dissociation constant
+ PatchedDataset:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ biomarker_types:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ subjects:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ protocols:
+ type: array
+ items:
+ $ref: '#/components/schemas/Protocol'
+ readOnly: true
+ name:
+ type: string
+ description: name of the dataset
+ maxLength: 100
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: date/time the experiment was conducted. All time measurements
+ are relative to this date/time, which is in YYYY-MM-DD HH:MM:SS format.
+ For example, 2020-07-18 14:30:59
+ description:
+ type: string
+ description: short description of the dataset
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ PatchedDose:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ start_time:
+ type: number
+ format: double
+ description: starting time point of dose, see protocol for units
+ amount:
+ type: number
+ format: double
+ description: amount of compound administered over the duration, see protocol
+ for units. Rate of administration is assumed constant
+ duration:
+ type: number
+ format: double
+ description: Duration of dose administration, see protocol for units. Duration
+ must be greater than 0.
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ protocol:
+ type: integer
+ description: protocol containing this dose
+ PatchedDosedPharmacokinetic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ mappings:
+ type: array
+ items:
+ $ref: '#/components/schemas/PkpdMapping'
+ components:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ mmt:
+ type: string
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ dose_compartment:
+ type: string
+ nullable: true
+ description: compartment name to be dosed
+ maxLength: 100
+ time_max:
+ type: number
+ format: double
+ description: suggested time to simulate after the last dose (in the time
+ units specified by the mmt model)
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ pk_model:
+ type: integer
+ nullable: true
+ description: model
+ pd_model:
+ type: integer
+ nullable: true
+ description: PD part of model
+ protocol:
+ type: integer
+ nullable: true
+ description: dosing protocol
+ PatchedInference:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ log_likelihoods:
+ type: array
+ items:
+ $ref: '#/components/schemas/LogLikelihood'
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the dataset
+ maxLength: 100
+ description:
+ type: string
+ description: short description of what this inference does
+ initialization_strategy:
+ $ref: '#/components/schemas/InitializationStrategyEnum'
+ number_of_chains:
+ type: integer
+ description: number of chains
+ max_number_of_iterations:
+ type: integer
+ description: maximum number of iterations
+ burn_in:
+ type: integer
+ description: final iteration of burn-in
+ number_of_iterations:
+ type: integer
+ description: number of iterations calculated
+ time_elapsed:
+ type: integer
+ description: Elapsed run time for inference in seconds
+ number_of_function_evals:
+ type: integer
+ description: number of function evaluations
+ task_id:
+ type: string
+ nullable: true
+ description: If executing, this is the celery task id
+ maxLength: 40
+ metadata:
+ type: object
+ additionalProperties: {}
+ description: metadata for inference
+ project:
+ type: integer
+ description: Project that "owns" this inference object
+ algorithm:
+ type: integer
+ description: algorithm used to perform the inference
+ initialization_inference:
+ type: integer
+ nullable: true
+ PatchedInferenceChain:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ data:
+ type: string
+ readOnly: true
+ outputs:
+ type: string
+ readOnly: true
+ inference:
+ type: integer
+ description: inference for this chain
+ PatchedPharmacodynamic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ components:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ mmt:
+ type: string
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the model
+ time_max:
+ type: number
+ format: double
+ description: suggested maximum time to simulate for this model (in the time
+ units specified by the mmt model)
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ PatchedPharmacokinetic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the model
+ mmt:
+ type: string
+ description: the model represented using mmt (see https://myokit.readthedocs)
+ time_max:
+ type: number
+ format: double
+ description: suggested maximum time to simulate for this model (in the time
+ units specified by the mmt model)
+ PatchedProject:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ user_access:
+ type: array
+ items:
+ $ref: '#/components/schemas/ProjectAccess'
+ name:
+ type: string
+ description: name of the project
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the project
+ compound:
+ type: integer
+ users:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ description: users with access to this project
+ PatchedProjectAccess:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: True if user has read access only
+ user:
+ type: integer
+ project:
+ type: integer
+ readOnly: true
+ PatchedProtocol:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ doses:
+ type: array
+ items:
+ $ref: '#/components/schemas/Dose'
+ readOnly: true
+ dose_ids:
+ type: array
+ items:
+ type: integer
+ writeOnly: true
+ writeOnly: true
+ dosed_pk_models:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ dataset:
+ type: string
+ readOnly: true
+ subjects:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the protocol
+ maxLength: 100
+ dose_type:
+ $ref: '#/components/schemas/DoseTypeEnum'
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this protocol.
+ compound:
+ type: integer
+ nullable: true
+ description: drug compound
+ time_unit:
+ type: integer
+ nullable: true
+ description: unit for the start_time and duration values stored in each
+ dose
+ amount_unit:
+ type: integer
+ nullable: true
+ description: unit for the amount value stored in each dose
+ PatchedSubject:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ id_in_dataset:
+ type: integer
+ description: unique id in the dataset
+ shape:
+ type: integer
+ description: Shape index associated with this subject. For plotting purposes
+ in the frontend
+ display:
+ type: boolean
+ description: True if this subject will be displayed in the frontend, False
+ otherwise
+ metadata:
+ type: string
+ description: subject metadata
+ dataset:
+ type: integer
+ description: dataset containing this subject
+ protocol:
+ type: integer
+ nullable: true
+ description: dosing protocol for this subject.
+ PatchedUnit:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ compatible_units:
+ type: array
+ items:
+ type: object
+ additionalProperties:
+ type: string
+ readOnly: true
+ symbol:
+ type: string
+ description: symbol for unit display
+ maxLength: 50
+ g:
+ type: number
+ format: double
+ description: grams exponent
+ m:
+ type: number
+ format: double
+ description: meters exponent
+ s:
+ type: number
+ format: double
+ description: seconds exponent
+ A:
+ type: number
+ format: double
+ description: ampere exponent
+ K:
+ type: number
+ format: double
+ description: kelvin exponent
+ cd:
+ type: number
+ format: double
+ description: candela exponent
+ mol:
+ type: number
+ format: double
+ description: mole exponent
+ multiplier:
+ type: number
+ format: double
+ description: multiplier in powers of 10
+ PatchedUser:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ username:
+ type: string
+ description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
+ only.
+ pattern: ^[\w.@+-]+$
+ maxLength: 150
+ first_name:
+ type: string
+ maxLength: 150
+ last_name:
+ type: string
+ maxLength: 150
+ email:
+ type: string
+ format: email
+ title: Email address
+ maxLength: 254
+ profile:
+ allOf:
+ - $ref: '#/components/schemas/Profile'
+ readOnly: true
+ project_set:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ PatchedVariable:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ is_public:
+ type: boolean
+ lower_bound:
+ type: number
+ format: double
+ description: lowest possible value for this variable
+ upper_bound:
+ type: number
+ format: double
+ description: largest possible value for this variable
+ default_value:
+ type: number
+ format: double
+ description: default value for this variable
+ is_log:
+ type: boolean
+ description: True if default_value is stored as the log of this value
+ name:
+ type: string
+ description: name of the variable
+ maxLength: 100
+ binding:
+ type: string
+ nullable: true
+ description: myokit binding of the variable (e.g. time)
+ maxLength: 100
+ qname:
+ type: string
+ description: fully qualitifed name of the variable
+ maxLength: 200
+ constant:
+ type: boolean
+ description: True for a constant variable of the model, i.e. a parameter.
+ False if non-constant, i.e. an output of the model (default is True)
+ state:
+ type: boolean
+ description: True if it is a state variable of the model and has an initial
+ condition parameter (default is False)
+ color:
+ type: integer
+ description: Color index associated with this variable. For display purposes
+ in the frontend
+ display:
+ type: boolean
+ description: True if this variable will be displayed in the frontend, False
+ otherwise
+ axis:
+ type: boolean
+ description: False/True if biomarker type displayed on LHS/RHS axis
+ unit:
+ type: integer
+ nullable: true
+ description: variable values are in this unit (note this might be different
+ from the unit in the stored sbml)
+ pd_model:
+ type: integer
+ nullable: true
+ description: pharmacodynamic model
+ pk_model:
+ type: integer
+ nullable: true
+ description: pharmacokinetic model
+ dosed_pk_model:
+ type: integer
+ nullable: true
+ description: dosed pharmacokinetic model
+ Pharmacodynamic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ components:
+ type: string
+ readOnly: true
+ variables:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ mmt:
+ type: string
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the model
+ time_max:
+ type: number
+ format: double
+ description: suggested maximum time to simulate for this model (in the time
+ units specified by the mmt model)
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this model
+ required:
+ - components
+ - id
+ - name
+ - variables
+ PharmacodynamicSbml:
+ type: object
+ properties:
+ sbml:
+ type: string
+ writeOnly: true
+ required:
+ - sbml
+ Pharmacokinetic:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the model
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the model
+ mmt:
+ type: string
+ description: the model represented using mmt (see https://myokit.readthedocs)
+ time_max:
+ type: number
+ format: double
+ description: suggested maximum time to simulate for this model (in the time
+ units specified by the mmt model)
+ required:
+ - id
+ - name
+ PkpdMapping:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ datetime:
+ type: string
+ format: date
+ readOnly: true
+ read_only:
+ type: boolean
+ readOnly: true
+ pkpd_model:
+ type: integer
+ description: PKPD model that this mapping is for
+ pk_variable:
+ type: integer
+ description: variable in PK part of model
+ pd_variable:
+ type: integer
+ description: variable in PD part of model
+ required:
+ - datetime
+ - id
+ - pd_variable
+ - pk_variable
+ - pkpd_model
+ - read_only
+ Profile:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ user:
+ type: integer
+ required:
+ - id
+ - user
+ Project:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ user_access:
+ type: array
+ items:
+ $ref: '#/components/schemas/ProjectAccess'
+ name:
+ type: string
+ description: name of the project
+ maxLength: 100
+ description:
+ type: string
+ description: short description of the project
+ compound:
+ type: integer
+ users:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ description: users with access to this project
+ required:
+ - compound
+ - id
+ - name
+ - user_access
+ - users
+ ProjectAccess:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: True if user has read access only
+ user:
+ type: integer
+ project:
+ type: integer
+ readOnly: true
+ required:
+ - id
+ - project
+ - user
+ Protocol:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ doses:
+ type: array
+ items:
+ $ref: '#/components/schemas/Dose'
+ readOnly: true
+ dose_ids:
+ type: array
+ items:
+ type: integer
+ writeOnly: true
+ writeOnly: true
+ dosed_pk_models:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ dataset:
+ type: string
+ readOnly: true
+ subjects:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ name:
+ type: string
+ description: name of the protocol
+ maxLength: 100
+ dose_type:
+ $ref: '#/components/schemas/DoseTypeEnum'
+ project:
+ type: integer
+ nullable: true
+ description: Project that "owns" this protocol.
+ compound:
+ type: integer
+ nullable: true
+ description: drug compound
+ time_unit:
+ type: integer
+ nullable: true
+ description: unit for the start_time and duration values stored in each
+ dose
+ amount_unit:
+ type: integer
+ nullable: true
+ description: unit for the amount value stored in each dose
+ required:
+ - dataset
+ - dose_ids
+ - dosed_pk_models
+ - doses
+ - id
+ - name
+ - subjects
+ Subject:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ id_in_dataset:
+ type: integer
+ description: unique id in the dataset
+ shape:
+ type: integer
+ description: Shape index associated with this subject. For plotting purposes
+ in the frontend
+ display:
+ type: boolean
+ description: True if this subject will be displayed in the frontend, False
+ otherwise
+ metadata:
+ type: string
+ description: subject metadata
+ dataset:
+ type: integer
+ description: dataset containing this subject
+ protocol:
+ type: integer
+ nullable: true
+ description: dosing protocol for this subject.
+ required:
+ - dataset
+ - id
+ - id_in_dataset
+ Unit:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ compatible_units:
+ type: array
+ items:
+ type: object
+ additionalProperties:
+ type: string
+ readOnly: true
+ symbol:
+ type: string
+ description: symbol for unit display
+ maxLength: 50
+ g:
+ type: number
+ format: double
+ description: grams exponent
+ m:
+ type: number
+ format: double
+ description: meters exponent
+ s:
+ type: number
+ format: double
+ description: seconds exponent
+ A:
+ type: number
+ format: double
+ description: ampere exponent
+ K:
+ type: number
+ format: double
+ description: kelvin exponent
+ cd:
+ type: number
+ format: double
+ description: candela exponent
+ mol:
+ type: number
+ format: double
+ description: mole exponent
+ multiplier:
+ type: number
+ format: double
+ description: multiplier in powers of 10
+ required:
+ - compatible_units
+ - id
+ - symbol
+ User:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ username:
+ type: string
+ description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
+ only.
+ pattern: ^[\w.@+-]+$
+ maxLength: 150
+ first_name:
+ type: string
+ maxLength: 150
+ last_name:
+ type: string
+ maxLength: 150
+ email:
+ type: string
+ format: email
+ title: Email address
+ maxLength: 254
+ profile:
+ allOf:
+ - $ref: '#/components/schemas/Profile'
+ readOnly: true
+ project_set:
+ type: array
+ items:
+ type: integer
+ readOnly: true
+ required:
+ - id
+ - profile
+ - project_set
+ - username
+ Variable:
+ type: object
+ properties:
+ id:
+ type: integer
+ readOnly: true
+ read_only:
+ type: boolean
+ description: true if object has been stored
+ datetime:
+ type: string
+ format: date-time
+ nullable: true
+ description: datetime the object was stored.
+ is_public:
+ type: boolean
+ lower_bound:
+ type: number
+ format: double
+ description: lowest possible value for this variable
+ upper_bound:
+ type: number
+ format: double
+ description: largest possible value for this variable
+ default_value:
+ type: number
+ format: double
+ description: default value for this variable
+ is_log:
+ type: boolean
+ description: True if default_value is stored as the log of this value
+ name:
+ type: string
+ description: name of the variable
+ maxLength: 100
+ binding:
+ type: string
+ nullable: true
+ description: myokit binding of the variable (e.g. time)
+ maxLength: 100
+ qname:
+ type: string
+ description: fully qualitifed name of the variable
+ maxLength: 200
+ constant:
+ type: boolean
+ description: True for a constant variable of the model, i.e. a parameter.
+ False if non-constant, i.e. an output of the model (default is True)
+ state:
+ type: boolean
+ description: True if it is a state variable of the model and has an initial
+ condition parameter (default is False)
+ color:
+ type: integer
+ description: Color index associated with this variable. For display purposes
+ in the frontend
+ display:
+ type: boolean
+ description: True if this variable will be displayed in the frontend, False
+ otherwise
+ axis:
+ type: boolean
+ description: False/True if biomarker type displayed on LHS/RHS axis
+ unit:
+ type: integer
+ nullable: true
+ description: variable values are in this unit (note this might be different
+ from the unit in the stored sbml)
+ pd_model:
+ type: integer
+ nullable: true
+ description: pharmacodynamic model
+ pk_model:
+ type: integer
+ nullable: true
+ description: pharmacokinetic model
+ dosed_pk_model:
+ type: integer
+ nullable: true
+ description: dosed pharmacokinetic model
+ required:
+ - id
+ - name
+ - qname
+ securitySchemes:
+ basicAuth:
+ type: http
+ scheme: basic
+ cookieAuth:
+ type: apiKey
+ in: cookie
+ name: sessionid
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 00000000..d9b14896
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,27 @@
+gunicorn
+Django==3.2.19
+setuptools<=65.5.1
+django-cors-headers>=3.7.0
+dpd-static-support>=0.0.5
+pandas>=1.0
+whitenoise>=5.0.1
+docutils>=0.16
+python-markdown-math>=0.8
+pints @ git+https://github.com/pints-team/pints@i1403-multi-outputs#egg=pints
+myokit @ git+https://github.com/MichaelClerx/myokit@main#egg=myokit
+django-extensions>=3.1.1
+jsonfield>=3.1.0
+djangorestframework>=3.12.4
+djoser>=2.1.0
+python-memcached>=1.16.0
+psycopg2-binary>=2.9.1
+dj-database-url>=0.5.0
+django-polymorphic>=3.1.0
+drf-writable-nested>=0.6.3
+celery>=5.1.2
+tdigest>=0.5.2.2
+pymc3>=3.11.5
+django-auth-ldap>=4.1.0
+pyyaml>=6.0.0
+drf-spectacular>=0.26.2
+openpyxl>=3.1.2
\ No newline at end of file
diff --git a/run-tests.py b/run-tests.py
new file mode 100644
index 00000000..051e0c58
--- /dev/null
+++ b/run-tests.py
@@ -0,0 +1,91 @@
+#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+# This file has been adapted from PINTS (https://github.com/pints-team/pints/)
+# which is released under the BSD 3-clause license.
+#
+
+from __future__ import absolute_import, division
+from __future__ import print_function, unicode_literals
+import argparse
+import datetime
+import os
+import sys
+
+
+def run_copyright_checks():
+ """
+ Checks that the copyright year in LICENSE.md is up-to-date and that each
+ file contains the copyright header
+ """
+ print('\nChecking that copyright is up-to-date and complete.')
+
+ year_check = True
+ current_year = str(datetime.datetime.now().year)
+
+ with open('LICENSE.md', 'r') as license_file:
+ license_text = license_file.read()
+ if 'Copyright (c) ' + current_year in license_text:
+ print("Copyright notice in LICENSE.md is up-to-date.")
+ else:
+ print('Copyright notice in LICENSE.md is NOT up-to-date.')
+ year_check = False
+
+ # Recursively walk the pkpd directory and check copyright header is in
+ # each checked file type
+ header_check = True
+ checked_file_types = ['.py']
+ copyright_header = """#
+# This file is part of PKPDApp (https://github.com/pkpdapp-team/pkpdapp) which
+# is released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#"""
+
+ for dirname, _, file_list in os.walk('pkpdapp'):
+ for f_name in file_list:
+ if any([f_name.endswith(x) for x in checked_file_types]):
+ path = os.path.join(dirname, f_name)
+ with open(path, 'r') as f:
+ if copyright_header not in f.read():
+ print('Copyright blurb missing from ' + path)
+ header_check = False
+
+ if header_check:
+ print('All files contain copyright header.')
+
+ if not year_check or not header_check:
+ print('FAILED')
+ sys.exit(1)
+
+
+if __name__ == '__main__':
+ # Set up argument parsing
+ parser = argparse.ArgumentParser(
+ description='Run tests for PKPDApp.',
+ # TODO:
+ epilog='To run individual unit tests, use e.g.'
+ ' $ pkpd/tests/test_toy_logistic_model.py',
+ )
+
+ # Copyright checks
+ parser.add_argument(
+ '--copyright',
+ action='store_true',
+ help='Check copyright runs to the current year',)
+
+ # Parse!
+ args = parser.parse_args()
+
+ # Run tests
+ has_run = False
+
+ # Copyright checks
+ if args.copyright:
+ has_run = True
+ run_copyright_checks()
+
+ # Help
+ if not has_run:
+ parser.print_help()
diff --git a/start-server.sh b/start-server.sh
new file mode 100755
index 00000000..7ec74e43
--- /dev/null
+++ b/start-server.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# start-server.sh
+if [ -n "$DJANGO_SUPERUSER_USERNAME" ] && [ -n "$DJANGO_SUPERUSER_PASSWORD" ] ; then
+ (python manage.py createsuperuser --no-input)
+fi
+(python manage.py migrate --no-input)
+(celery -A pkpdapp worker --loglevel=INFO) &
+(gunicorn pkpdapp.wsgi:application --bind unix:/run/gunicorn.socket --workers 3) &
+nginx -g "daemon off;"
+