pbpk-lite 0.0.1__tar.gz

pbpk_lite-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Gregor Čekada cekada.gregor@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pbpk_lite-0.0.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: pbpk-lite
+Version: 0.0.1
+Summary: This is a simple implementation of PBPK modeling in python.
+Project-URL: Homepage, https://github.com/cekadagregor/pbpk-lite
+Project-URL: Issues, https://github.com/cekadagregor/pbpk-lite/issues
+Author-email: Gregor Čekada <cekada.gregor@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: model,pbpk,pharmacokinetics
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: scipy>=1.12.0
+Description-Content-Type: text/markdown
+
+# pbpk-lite
+
+This is a simple implementation of PBPK modeling in python.

pbpk_lite-0.0.1/README.md

@@ -0,0 +1,3 @@
+# pbpk-lite
+
+This is a simple implementation of PBPK modeling in python.

pbpk_lite-0.0.1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pbpk-lite"
+version = "0.0.1"
+keywords = ["pbpk", "pharmacokinetics", "model"]
+authors = [
+  { name="Gregor Čekada", email="cekada.gregor@gmail.com" },
+]
+description = "This is a simple implementation of PBPK modeling in python."
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "scipy>=1.12.0",
+    "numpy>=2.0.0",
+    "matplotlib>=3.8.0",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+
+[project.urls]
+Homepage = "https://github.com/cekadagregor/pbpk-lite"
+Issues = "https://github.com/cekadagregor/pbpk-lite/issues"

pbpk_lite-0.0.1/src/pbpk_lite/__init__.py

@@ -0,0 +1,3 @@
+from .main import model
+
+__all__ = ["model"]

pbpk_lite-0.0.1/src/pbpk_lite/distribution_params.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+V_a = np.array((143, 124, 20.7, 23.6, 3.8, 4.4, 24.1, 16.7, 429, 1.2, 111, 2.7, 2.2, 0.51, 25.7, 51.4)) # kg/mL
+def V_function(bw): return V_a * bw
+
+Q_a = np.array((3.7, 3.6, 10, 13, 2.14, 15.7, 21, 71, 10.7, 1.9, 4.3, 1.1, 0.56, 0.04)) # mL/min/kg
+def Q_function(bw): return Q_a * (bw**0.75)
+
+# phospholipid, neutral lipid, water
+Tissue_composition = np.array(((0.002, 0.79, 0.18),
+(0.0005, 0.074, 0.439),
+(0.0565, 0.051, 0.77),
+(0.0163, 0.0487, 0.718),
+(0.0166, 0.0115, 0.758),
+(0.0162, 0.0207, 0.783),
+(0.0252, 0.0348, 0.751),
+(0.009, 0.003, 0.811),
+(0.0072, 0.0238, 0.76),
+(0.0188, 0.0723, 0.66),
+(0.0111, 0.0284, 0.718),
+(0.0198, 0.0201, 0.788),
+(0.0182, 0.0338, 0.784),
+(0, 0, 0.859),
+(0.0033, 0.0022, 0.651),
+(0.00225, 0.0035, 0.945))) # L/kg
+
+f_pl = Tissue_composition[:, 0]
+f_nl = Tissue_composition[:, 1]
+f_w = Tissue_composition[:, 2]
+
+f_pl_p = 0.067
+f_nl_p = 0.0012
+f_w_p = 0.939
+
+def partition_model(logp, fu):
+    fut = 1/(1 + 0.5*((1-fu)/fu))
+    p_ow = 10**logp
+
+    k_p = fu*(p_ow*(f_nl + 0.3*f_pl) + f_w + 0.7*f_pl)/(p_ow*(f_nl_p + 0.3*f_pl_p) + f_w_p + 0.7*f_pl_p)
+    k_p[1:] /= fut
+    return k_p

pbpk_lite-0.0.1/src/pbpk_lite/graph.py

@@ -0,0 +1,26 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+compartment_names = ['adipose', 'bone', 'brain' , 'gut', 'heart', 'kidney', 'liver', 'lung', 'muscle', 'pancreas', 'skin', 'spleen', 'stomach', 'testes', 'arterial_blood', 'venous_blood']
+
+def identify_compartment(arg):
+    if type(arg) == int:
+        return compartment_names[arg]
+    else:
+        return compartment_names.index(arg)
+
+def matrix_index():
+    for i in range(4):
+        for j in range(4):
+            yield i, j
+
+def graph_whole_helper(time, concentrations, save_as):
+    plt.rcParams['font.size'] = 8
+    fig, axs = plt.subplots(4, 4, layout='constrained', sharex=True, figsize=(6.27, 3.5), dpi=300)
+    comp = 0
+    for i in matrix_index():
+        axs[i].plot(time, concentrations[comp, :])
+        axs[i].set_title(identify_compartment(comp))
+        axs[i].set_facecolor('#F2F2F2')
+        comp += 1
+    plt.savefig(save_as, dpi=300, bbox_inches="tight")

pbpk_lite-0.0.1/src/pbpk_lite/main.py

@@ -0,0 +1,110 @@
+import numpy as np
+from .distribution_params import V_function, Q_function, partition_model
+from .graph import graph_whole_helper
+from .solve import solver
+from .ode_system import system_generator
+
+class model:
+    def __init__(self):
+        # placeholder parameters
+        logp = 6.97
+        fu = 0.0022448
+        bw = 70
+        self.partition_coefficients = partition_model(logp, fu)
+        self.blood_flows = Q_function(bw)
+        self.volumes = V_function(bw)
+
+        cl_k = 0
+        cl_l = 10
+        def elimination(c):
+            outflow = np.zeros(16)
+            outflow[5] += cl_k*c[5]
+            outflow[6] += cl_l*c[6]
+            return outflow
+
+        self.elimination = elimination
+
+    def set_substance(self, log_p, fu):
+        """
+        Set the substance that is being investigated.
+
+        Parameters
+        ----------
+        log_p : float
+            Log of the octanol water partition of the substance.
+        fu : float
+            Free unbound value of the substance.
+        """
+    
+        self.partition_coefficients = partition_model(log_p, fu)
+        self.odes = system_generator(self.volumes, self.blood_flows, self.partition_coefficients, self.elimination)
+
+    def set_patient(self, bw):
+        """
+        Set the patient's distribution parameters.
+
+        Parameters
+        ----------
+        bw : float
+            Patient's body weight.
+        """
+        
+        self.blood_flows = Q_function(bw)
+        self.volumes = V_function(bw)
+        self.odes = system_generator(self.volumes, self.blood_flows, self.partition_coefficients, self.elimination)
+    
+    def set_elimination(self, /, cl_l = 0, cl_k= 0):
+        '''
+        Set the elimination parameters.
+
+        Parameters
+        ----------
+        cl_l : float
+            Clearance from the liver based linearly on concentration.
+        cl_k : float
+            Clearance from the kidney based linearly on concentration.
+        '''
+
+        def elimination(c):
+            outflow = np.zeros(16)
+            outflow[5] += cl_k*c[5]
+            outflow[6] += cl_l*c[6]
+            return outflow
+
+        self.elimination = elimination
+        self.odes = system_generator(self.volumes, self.blood_flows, self.partition_coefficients, self.elimination)
+    
+    def solve(self, doses, times):
+        """
+        Set the administration regime and solve the system of odes.
+        
+        Each dose at index i is administered at time at index i.
+        
+        Parameters
+        ----------
+        doses : array-like
+            A list of all doses.
+        times : array-like
+            A list of times at which doses ware given.
+        
+        Returns
+        -------
+        t : ndarray
+            Times at which there is some c.
+        c : ndarray
+            Concentrations in each tissue at given t.
+        """
+
+        self.t, self.c = solver(self.odes, doses, times, self.volumes)
+        return self.t, self.c
+        
+    def graph_whole(self, name):
+        """
+        Graph the concentrations in each tissue and save the figure.
+        
+        Parameters
+        ----------
+        name : str
+            File path to save the figure.
+        """
+        graph_whole_helper(self.t, self.c, name)

pbpk_lite-0.0.1/src/pbpk_lite/ode_system.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+# 0 adipose, 1 bone, 2 brain, 3 gut, 4 heart, 5 kidney, 6 liver, 7 lung, 8 muscle, 
+# 9 pancreas, 10 skin, 11 spleen, 12 stomach, 13 testes, 14 arterial blood, 15 venous blood
+
+arterial_input = np.ones(14)
+arterial_input[7] = 0
+
+liver_input = np.zeros(14)
+liver_input[11] = 1
+liver_input[9] = 1
+liver_input[12] = 1
+liver_input[3] = 1
+
+venous_input = np.ones(14)
+venous_input[7] = 0
+venous_input[11] = 0
+venous_input[9] = 0
+venous_input[12] = 0
+venous_input[3] = 0
+
+no_lung = np.ones(14)
+no_lung[7] = 0
+
+iv_input = 0
+ia_input = 0
+
+
+def system_generator(V, Q, K, elimination):
+    def inner(t, A):
+        C = A/V
+        dA = np.zeros(16)
+        dA[7] = Q[7]*(C[15] - C[7]/K[7])
+        dA[:14] += no_lung*Q*(C[14] - C[:14]/K[:14])
+        dA[6] += sum(liver_input*Q*C[:14]/K[:14])
+        dA -= elimination(C)
+        dA[15] = - Q[7]*C[15] + sum(venous_input*Q*C[:14]/K[:14]) + iv_input
+        dA[14] = Q[7]*C[7]/K[7] - (sum(Q) - Q[7])*C[14] + ia_input
+        return dA
+    return inner

pbpk_lite-0.0.1/src/pbpk_lite/solve.py

@@ -0,0 +1,26 @@
+from scipy.integrate import solve_ivp
+import numpy as np
+
+def solver(ode_system, doses, times, volumes):
+    t_full = np.array([])
+    a_full = np.array([[] for i in range(16)])
+
+    for i in range(len(doses)):
+        dose = doses[i]
+        time_interval = times[i:i+2]
+        if i == 0:
+            a0 = np.zeros(16)
+        else:
+            a0 = a_full[:, -1]
+        a0[15] += dose # iv_bolus
+
+        sol = solve_ivp(ode_system, time_interval, a0)
+        t_partial = sol.t
+        a_partial = sol.y
+
+        t_full = np.concatenate((t_full, t_partial))
+        a_full = np.concatenate((a_full, a_partial), axis=1)
+
+    volumes = volumes[:, np.newaxis]
+    c_full = a_full/volumes
+    return t_full, c_full