cosmopharm 0.0.21__py3-none-any.whl → 0.0.23__py3-none-any.whl

cosmopharm/actmodels/actmodel.py

@@ -1,26 +1,18 @@
 import numpy as np
 import numbers
+from numpy.typing import NDArray
+from typing import List, Literal
 
+from ..components import Component
 from ..utils.convert import convert
 
 class ActModel:
 
-    def __init__(self, components: list = []):
-        self.mix = components
+    def __init__(self, components: List[Component]):
+        self.mixture = components
 
     def lngamma(self, T, x):
-        pass
-
-    def dlngamma(self, T, x):
-        # Only binary case
-        def f(x1):
-            x = np.array([x1, 1-x1])
-            return self.lngamma(T, x)#[0]
-        h, x = 0.0001, x[0]
-        dy = (f(x+h)-f(x-h))/(2*h)
-        # Revert direction of dy2_dx2 --> dy2_dx1
-        dy[1] = dy[1][::-1]
-        return f(x), dy
+        raise NotImplementedError("lngamma() hasn't been implemented yet.")
 
     def activity(self, T, x):
         act = np.log(x) + self.lngamma(T, x)
@@ -28,6 +20,7 @@ class ActModel:
         return act
 
     def gmix(self, T, x):
+        is_scalar = np.isscalar(x)
         # Convert input as needed
         x = self._convert_input(x)
         # Create mask to identify columns that don't contain 0 or 1
@@ -38,10 +31,10 @@ class ActModel:
         _gmix = _x * (np.log(_x) + self.lngamma(T, _x))
         _gmix = np.sum(_gmix, axis=0)
         # Initialize gmix array with zeros
-        gmix = np.zeros(x.shape[1])
+        gmix = np.zeros(1 if x.ndim==1 else x.shape[1])
         # Fill gmix with calculated values where the mask is True
         gmix[mask] = _gmix
-        return gmix
+        return gmix[0] if is_scalar else gmix
 
 
 # =============================================================================
@@ -74,10 +67,41 @@ class ActModel:
         """Converts input to a 1-dim ndarray if it's a number or 0-dim ndarray."""
         if isinstance(x, numbers.Number) or (isinstance(x, np.ndarray) and x.ndim == 0):
             return np.array([float(x), 1 - float(x)])
-        elif isinstance(x, np.ndarray) and x.ndim == 1 and len(x) != len(self.mix):
+        elif isinstance(x, np.ndarray) and x.ndim == 1 and len(x) != len(self.mixture):
             return np.array([x, 1 - x])
         return x
 
-    def _convert(self, x, to='weight'):
-        Mw = np.array([c.Mw for c in self.mix])
-        return convert(x=np.array([x, 1-x]), Mw=Mw, to=to)[0]
+    def _convert(self, 
+                 x : NDArray[np.float64], 
+                 to : Literal['weight', 'mole'] ='weight'
+                 ) -> NDArray[np.float64]:
+        """
+        Convert the fraction of a binary mixture between mole fraction and weight fraction.
+
+        This method is designed for internal use with binary mixtures, where the mixture is defined by two components. 
+        It uses the 'convert' function to perform the conversion by creating an array with the fractions of both 
+        components and the molecular weights from the mixture's attributes.
+
+        Parameters:
+            x (NDArray[np.float64]): The mole or weight fraction of the first component of the mixture. 
+                                    If converting 'to' weight, 'x' represents mole fractions; if converting 'to' mole, 
+                                    'x' represents weight fractions. This should be a single value or a 1D array of values.
+            to (Literal['weight', 'mole'], optional): The target type for the conversion. Defaults to 'weight'.
+                                                    Use 'weight' to convert mole fractions to weight fractions,
+                                                    and 'mole' to convert weight fractions to mole fractions.
+
+        Returns:
+            NDArray[np.float64]: The converted fraction(s) of the first component in the same shape as 'x'.
+                                If 'x' is a single value, the return will be a single converted value;
+                                if 'x' is a 1D array, the return will be a 1D array of converted values.
+
+        Example:
+            >>> mixture = Mixture(components=[component1, component2], Mw=np.array([18.01528, 46.06844]))
+            >>> sle = SLE(mix=mixture)
+            >>> x_mole_fraction = np.array([0.4])  # Mole fraction of the first component
+            >>> x_weight_fraction = sle._convert(x_mole_fraction, to='weight')
+            >>> print(x_weight_fraction)
+            array([0.01373165])
+        """
+        Mw = np.array([c.Mw for c in self.mixture])
+        return convert(x=np.array([x, 1-x], dtype=np.float64), Mw=Mw, to=to)[0]

cosmopharm/actmodels/cosmo.py

@@ -1,17 +1,25 @@
+
 import numpy as np
+import cCOSMO
+
+from typing import List, Union, Literal
 from .actmodel import ActModel
+from ..components import Component
 
 class COSMOSAC(ActModel):
-    def __init__(self, COSMO, components: list, free_volume=False,
-                 dispersion=False, combinatorial=True):
+    def __init__(self,
+                 COSMO: Union[cCOSMO.COSMO1, cCOSMO.COSMO3],
+                 mixture: List[Component],
+                 combinatorial: Union[Literal['sg', 'fv'], bool] = 'sg',
+                 dispersion: bool = False,
+                 ) -> None:
         self.COSMO = COSMO
-        self.mix = components
+        self.mixture = mixture
         # Flexible assignment of 'get_lngamma_comb' and 'get_lngamma_dsp'
-        # that changes dynamically if the values for 'free_volume', 'dispersion'
-        # or "combinatorial" are changed after initialization of an instance.
-        self._free_volume = free_volume
-        self._dispersion = dispersion
+        # that changes dynamically if the values for 'combinatorial' or
+        # 'dispersion' are changed after initialization of an instance.
         self._combinatorial = combinatorial
+        self._dispersion = dispersion
 
     @ActModel.vectorize
     def lngamma(self, T, x):
@@ -54,8 +62,8 @@ class COSMOSAC(ActModel):
         (can replace ln_gamma_comb of normal COSMO-SAC) - Kuo2013
         x, v_298, v_hc are 1D arrays (number of elements = number of components)
         """
-        v_298 = np.array([c.v_298 for c in self.mix])
-        v_hc = np.array([c.v_hc for c in self.mix])
+        v_298 = np.array([comp.v_298 for comp in self.mixture])
+        v_hc = np.array([comp.v_hc for comp in self.mixture])
         vf = v_298-v_hc
         sum_vf = np.sum(x*vf)
         phix = vf/sum_vf
@@ -68,12 +76,12 @@ class COSMOSAC(ActModel):
         return self.COSMO.get_lngamma_resid(T, x)
 
     def get_lngamma_comb(self, x):
-        if not self._combinatorial:
+        if self._combinatorial is False:
             return np.zeros(len(x))
-        elif self._free_volume:
-            return self.get_lngamma_fv(x)
-        else:
+        elif self._combinatorial.lower() == 'sg':
             return self.get_lngamma_sg(x)
+        elif self._combinatorial.lower() == 'fv':
+            return self.get_lngamma_fv(x)
 
     def get_lngamma_disp(self, x):
         if self._dispersion:
@@ -81,14 +89,6 @@ class COSMOSAC(ActModel):
         else:
             return np.zeros(len(x))
 
-    @property
-    def free_volume(self):
-        return self._free_volume
-
-    @free_volume.setter
-    def free_volume(self, value):
-        self._free_volume = value
-
     @property
     def dispersion(self):
         return self._dispersion
@@ -102,5 +102,22 @@ class COSMOSAC(ActModel):
         return self._combinatorial
 
     @combinatorial.setter
-    def combinatorial(self, value):
-        self._combinatorial = value
+    def combinatorial(self, value: Union[str, bool]):
+        is_valid_string = isinstance(value, str) and value.lower() in ('sg', 'fv')
+        is_False = value is False
+        if is_valid_string or is_False:
+            self._combinatorial = value
+        else:
+            msg = "Invalid value for combinatorial term. Please choose 'sg', 'fv', or set to False."
+            raise ValueError(msg)
+
+# =============================================================================
+# Auxilliary functions
+# =============================================================================
+    def configuration(self,
+                      comb: Union[Literal['sg', 'fv'], bool] = 'sg',
+                      dsp: bool = False, **kwargs
+                      ):
+        """ Convenience function to quickly configure COSMO parameters """
+        self._combinatorial = comb
+        self._dispersion = dsp

cosmopharm/equilibrium/lle.py

@@ -1,34 +1,48 @@
 import numpy as np
 import pandas as pd
-from scipy.optimize import least_squares
+from scipy.optimize import least_squares, root
+from typing import Union, Optional, Type, List
 
-from ..utils import spacing
+from ..components import Component
+from ..actmodels import ActModel
+from ..utils.spacing import spacing
 from ..utils.lle_scanner import estimate_lle_from_gmix
 
 
 class LLE:
-    def __init__(self, actmodel):
-        self.mix = actmodel.mix
-        self.model  = actmodel
+    def __init__(self,
+                 actmodel: Union[ActModel, Type[ActModel]],
+                 mixture: Optional[List[Component]] = None) -> None:
+        self.actmodel = actmodel
+        self.mixture = mixture
+        self._validate_arguments()
 
     def fobj_binodal(self, x1, T):
         # Equilibrium: Isoactivity criterion (aL1 - aL2 = 0)
         x = np.array([x1, 1-x1])
-        activity = self.model.activity(T, x)
+        activity = self.actmodel.activity(T, x)
         equilibrium = np.diff(activity, axis=1)
         return equilibrium.ravel() # reshape from (2,1) --> (2,)
 
     def fobj_spinodal(self, x1):
         T = 0
         x = np.array([x1, 1-x1])
-        return self.model.thermofac(T, x)
+        return self.actmodel.thermofac(T, x)
 
-    def binodal(self, T, x0=None):
+    def binodal(self, T, x0=None, solver='least_squares'):
         if x0 is None:
             x0 = [0.1, 0.999]    # 1_N2_Ethan
-        kwargs = dict(bounds=(0,1), ftol=1e-15, xtol=1e-15)
-        res = least_squares(self.fobj_binodal, x0, args=(T,), **kwargs)
-        return res.x
+
+        if solver == 'least_squares':
+            kwargs = dict(bounds=(0,1), ftol=1e-15, xtol=1e-15)
+            res = least_squares(self.fobj_binodal, x0, args=(T,), **kwargs)
+            # print(res.nfev)
+            return res.x, res.nfev
+        else:
+            kwargs = dict(method='krylov', options={'maxiter': 5})
+            res = root(self.fobj_binodal, x0, args=(T,), **kwargs)
+            # print(res.nit)
+            return res.x, 30
 
     def spinodal(self, x0=None):
         if x0 is None:
@@ -36,26 +50,28 @@ class LLE:
         return least_squares(self.fobj_spinodal, x0).x
 
 # =============================================================================
-#
+# TODO: (1) Add some "approx_initial_values" function based on gmix
+# TODO: (2) Overall improve this code to match the SLE code
 # =============================================================================
     def approx_init_x0(self, T):
         x1 = spacing(0,1,51,'poly',n=3)
-        gmix = self.model.gmix(T, x1)
+        gmix = self.actmodel.gmix(T, x1)
         xL, xR, yL, yR = estimate_lle_from_gmix(x1, gmix, rough=True)
         return xL, xR
 
-    def solve_lle(self, T, x0, info=True):
-        binodal_x = self.binodal(T, x0)
-        binodal_w = self.model._convert(binodal_x)
+    def solve_lle(self, T, x0, solver='least_squares', info=True):
+        binodal_x, nfev = self.binodal(T, x0, solver)
+        binodal_w = self.actmodel._convert(binodal_x)
         formatted_w_binodal = [f"wL{i+1}={value:.4f}" for i, value in enumerate(binodal_w)]
         formatted_x_binodal = [f"xL{i+1}={value:.6f}" for i, value in enumerate(binodal_x)]
         msg = ('LLE: ', f"{T=:.2f}", *formatted_w_binodal, *formatted_x_binodal)
         if info:
             print(*msg)
-            return binodal_x, binodal_w
-        return binodal_x, binodal_w, msg
+            return binodal_x, binodal_w, nfev
+        return binodal_x, binodal_w, nfev, msg
 
-    def miscibility(self, T, x0=None, max_gap=0.1, max_T=500, dT=25):
+    def miscibility(self, T, x0=None, max_gap=0.1, max_T=500, dT=25, exponent=2):
+        """ Calculate miscibility """
         print()
         print("Calculating LLE...")
         res = []
@@ -63,27 +79,48 @@ class LLE:
         if x0 is None:
             print("...searching for suitable initial value...")
             x0 = self.approx_init_x0(T)
-        binodal_x, binodal_w, msg = self.solve_lle(T, x0, info=False)
+        binodal_x, binodal_w, nfev, msg = self.solve_lle(T, x0, info=False)
 
         # Check if initial guess is reasonalble - otherwise increase T
         while binodal_x[0] < x0[0] and T <= max_T:
             print('LLE: ', f"{T=:.2f}", "...no feasbible initial value found.")
             T += 10  # Increase T by 10
             x0 = self.approx_init_x0(T)
-            binodal_x, binodal_w, msg = self.solve_lle(T, x0, info=False)
+            binodal_x, binodal_w, nfev, msg = self.solve_lle(T, x0, info=False)
         print("Suitable initial value found! Proceed with calculating LLE...")
         print(*msg)
         gap = np.diff(binodal_w)[0]
         res.append((T, *binodal_w, *binodal_x))
 
-        exponent = 2.1
         while gap > max_gap and T <= max_T:
+            solver = 'least_squares' if nfev <= 30 else 'root'
+            solver = 'least_squares'
+            # print(solver)
             T += dT * gap**exponent
             x0 = binodal_x
-            binodal_x, binodal_w = self.solve_lle(T, x0)
+            binodal_x, binodal_w, nfev = self.solve_lle(T, x0, solver)
             gap = np.diff(binodal_w)[0]
             res.append((T, *binodal_w, *binodal_x))
 
         columns = ['T', 'wL1', 'wL2', 'xL1', 'xL2']
         res = pd.DataFrame(res, columns=columns)
         return res
+
+# =============================================================================
+# AUXILLIARY FUNCTIONS
+# =============================================================================
+    def _validate_arguments(self):
+        """Validate the arguments for the LLE class."""
+        # TODO: Insert case where both actmodel and mixture are provided (check if acmodel.mixture == mixture, if not raise warning)
+        if isinstance(self.actmodel, ActModel):
+            # If actmodel is an instance of ActModel
+            self.mixture: List[Component] = self.mixture or self.actmodel.mixture
+        elif isinstance(self.actmodel, type) and issubclass(self.actmodel, ActModel):
+            # If actmodel is a class (subclass of ActModel)
+            if self.mixture is None:
+                raise ValueError("Please provide a valid mixture:Mixture.")
+            self.actmodel: ActModel = self.actmodel(self.mixture)
+        else:
+            # If actmodel is neither an instance nor a subclass of ActModel
+            err = "'actmodel' must be an instance or a subclass of 'ActModel'"
+            raise ValueError(err)

cosmopharm/equilibrium/sle.py

@@ -1,35 +1,47 @@
-import pandas as pd
 import numpy as np
+import pandas as pd
 from scipy.optimize import fsolve, root
-from typing import Literal
+from numpy.typing import NDArray
+from typing import Literal, Optional, Type, Union, List, Tuple, Generator, Dict
 
 from ..components import Component
+from ..actmodels import ActModel
 from ..utils.spacing import spacing
 
+NumericOrFrame = Union[float, List[float], Tuple[float, ...], NDArray[np.float64], pd.DataFrame]
+
 class SLE:
-    def __init__(self, solute, solvent, actmodel):
-        self.mix = [solute, solvent]
-        self.model = actmodel
-        self.solute, self.solvent = solute, solvent
+    def __init__(self,
+                 actmodel: Union[ActModel, Type[ActModel]],
+                 mixture: Optional[List[Component]] = None) -> None:
+        self.actmodel = actmodel
+        self.mixture = mixture
+        self._validate_arguments()
+        # Assign 'solute' and 'solvent' based on order in 'mixture'
+        # Default assignment can be changed in e.g. 'solubility()'
+        self.solute, self.solvent = self.mixture
 
     def solubility(self,
-                   solute: Component = None, solvent: Component = None,
-                   args=None, init=None, data=None,
+                   solute: Optional[Component] = None,
+                   solvent: Optional[Component] = None,
                    vary: Literal['T', 'w', 'auto'] = 'auto',
-                   mix: Literal['ideal', 'real'] = 'real',
+                   mix_type: Literal['ideal', 'real'] = 'real',
+                   args: Optional[NumericOrFrame] = None,
+                   init: Optional[NumericOrFrame] = None,
                    solver: Literal['root', 'fsolve'] = 'root',
-                   show_progress=False):
+                   show_progress=False, **kwargs):
         ''' Calculate solubility curve of solute in solvent.'''
         self.solute = solute or self.solute
         self.solvent = solvent or self.solvent
-        self.vary, self.mix_type = vary, mix
+        self.vary, self.mix_type = vary, mix_type
         self.show_progress = show_progress
+        self.config = getattr(self.actmodel, 'config', self.mix_type)
         if self.vary == 'auto':
             gen = self.auto_solve(solver)
         else:
             self._vary = self.vary
-            if args is None or init is None:
-                args, init = self.initialize(init=init, data=data)
+            args = self.set_args(args)
+            init = self.set_x0(init)
             gen = self.solve_sle(args, init, solver)
         res = [k for k in gen]
         res = pd.DataFrame(res, columns=['T', 'x', 'vary', 'w'])
@@ -40,33 +52,40 @@ class SLE:
 # =============================================================================
 # MATHEMATICS
 # =============================================================================
-    def solve_sle(self, args, init, solver='root'):
-        is_iterable = hasattr(init, "__len__") and len(init) > 1
+    def solve_sle(self, args: NDArray[np.float64], init: NDArray[np.float64],
+                  solver: Literal['root', 'fsolve'] = 'root'
+                  ) -> Generator[Dict[str, Union[float, str]], None, None]:
+        # Check compatibility of the "init" values
+        is_iterable = init.size > 1
+        if is_iterable and not init.size == args.size:
+            msg = 'The length of "init" must be the same as "args".'
+            raise ValueError(msg)
+        x0 = init
+        # Setup solver and handle pure component case
         key, lock = ['T', 'x'] if self._vary == 'T' else ['x', 'T']
         solve = self.set_solver(solver=solver)
-        x0 = init
         args, pure_component = self._handle_pure_component(args)
         if pure_component: # no need to calculate pure component
             yield pure_component
-
         for i, arg in enumerate(args):
             x0 = init[i] if is_iterable else x0
             out = float(solve(x0, arg))
             x0 = out if not is_iterable else x0
             res = {key: arg, lock: out, 'vary': self._vary}
-            res['w'] = self.model._convert(res['x'])[0]
+            res['w'] = self.actmodel._convert(res['x'])[0]
             text = (f"T={res['T']:.2f}", f"w={res['w']:.4f}", f"x={res['x']:.4f}")
             if self.show_progress:
-                print(f'SLE ({self.mix_type}): ', *text)
+                print(f'SLE ({self.config}): ', *text)
             yield res
 
     def auto_solve(self, solver: Literal['root', 'fsolve'] = 'root'):
         if self.show_progress:
             print()
-            print(f"Calculating SLE ({self.mix_type})...")
+            print(f"Calculating SLE ({self.config})...")
         # Start with varying 'w' until dTdw > THRESHOLD
         self._vary = 'w'
-        args, x0 = self.initialize()
+        args = self.set_args()
+        x0 = self.set_x0()
         gen = self.solve_sle(args, x0, solver)
         previous = None
         for i, current in enumerate(gen):
@@ -77,10 +96,7 @@ class SLE:
         # Switch to varying 'T'
         self._vary = 'T'
         T0, x0 = current['T'], current['x']
-        # # (Deprecated): If last dT>5, make the next dT=5 (from old version)
-        # T1 = previous['T']; dT = T0 - T1
-        # T0 += dT if abs(dT) < 5 else np.sign(dT) * 5
-        args = self.set_args(xmax=T0)[1:]  # exclude initial point (redundant)
+        args = self.set_args(xmax=T0)[1:]  # exclude initial point
         gen = self.solve_sle(args, x0)
         yield from gen
 
@@ -92,7 +108,7 @@ class SLE:
         return np.exp(-self.gibbs_fusion(T))
 
     def real_mix(self, T, x):
-        lngamma = self.model.lngamma(T, x)[0]
+        lngamma = self.actmodel.lngamma(T, x)[0]
         return np.log(x) + lngamma + self.gibbs_fusion(T)
 
     # Gibbs energy of fusion, i.e., the right-hand side of the solubility equation:
@@ -115,12 +131,12 @@ class SLE:
 # =============================================================================
 # HELPER FUNCTIONS
 # =============================================================================
-    def initialize(self, xmin=None, xmax=None, dx=None, data=None, init=None):
-        args = self.set_args(xmin, xmax, dx, data)
-        x0 = self.set_x0(init)
-        return args, x0
-
-    def set_args(self, xmin=None, xmax=None, dx=None, data=None):
+    def set_args(self,
+                 args: Optional[NumericOrFrame] = None,
+                 xmin: Optional[float] = None,
+                 xmax: Optional[float] = None,
+                 dx: Optional[float] = None
+                 ) -> NDArray[np.float64]:
         vary = self._vary
         # Determine argument values based on input data or generate
         # them based on range and type
@@ -132,7 +148,7 @@ class SLE:
         ma = defaults[vary]['max'] if xmax is None else xmax
         dx = defaults[vary]['step'] if dx is None else dx
 
-        if data is None:
+        if args is None:
             if self.vary != 'auto':  # auto_vary == False
                 args = np.arange(ma, mi-dx, -dx)
                 args[-1] = np.maximum(args[-1], mi)
@@ -145,17 +161,18 @@ class SLE:
             else:  # vary == 'w'
                 num = 16 if self.mix_type == 'ideal' else 21
                 args = spacing(ma, mi, num, 'quadratic')
-        else:
-            args = data
-        return args if vary != 'w' else self.model._convert(args, to='mole')
+        args = np.asarray(args)
+        args = args if vary != 'w' else self.actmodel._convert(args, to='mole')
+        return args
 
-    def set_x0(self, init=None):
+    def set_x0(self, init: Optional[NumericOrFrame] = None) -> NDArray[np.float64]:
         vary = self._vary
         # Set up initial values based on the type of variable ('T' or 'w')
         if vary == 'T':
-            x0 = 1. if init is None else self.model._convert(init, to='mole')
+            x0 = 1. if init is None else self.actmodel._convert(init, to='mole')
         else:  # vary == 'w'
             x0 = self.solute.T_fus if init is None else init
+        x0 = np.asarray(x0)
         return x0
 
     def set_solver(self, solver: Literal['root', 'fsolve'] = 'root'):
@@ -205,3 +222,19 @@ class SLE:
             args = args[args != 1]
             return args, res
         return args, None
+
+    def _validate_arguments(self):
+        """Validate the arguments for the SLE class."""
+        # TODO: Insert case where both actmodel and mixture are provided (check if acmodel.mixture == mixture, if not raise warning)
+        if isinstance(self.actmodel, ActModel):
+            # If actmodel is an instance of ActModel
+            self.mixture: List[Component] = self.mixture or self.actmodel.mixture
+        elif isinstance(self.actmodel, type) and issubclass(self.actmodel, ActModel):
+            # If actmodel is a class (subclass of ActModel)
+            if self.mixture is None:
+                raise ValueError("Please provide a valid mixture:Mixture.")
+            self.actmodel: ActModel = self.actmodel(self.mixture)
+        else:
+            # If actmodel is neither an instance nor a subclass of ActModel
+            err = "'actmodel' must be an instance or a subclass of 'ActModel'"
+            raise ValueError(err)

cosmopharm-0.0.23.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: cosmopharm
+Version: 0.0.23
+Summary: Predictive modeling for drug-polymer compatibility in pharmaceutical formulations using COSMO-SAC.
+Home-page: https://github.com/ivanantolo/cosmopharm,
+Author: Ivan Antolovic
+Author-email: Ivan.Antolovic@tu-berlin.de
+Maintainer: Martin Klajmon
+Maintainer-email: Martin.Klajmon@vscht.cz
+License: MIT
+Keywords: Drug-Polymer Compatibility,Amorphous Solid Dispersions,Pharmaceutical Formulation,COSMO-SAC Model,Solubility Prediction,Miscibility Analysis,Phase Behavior Prediction,Pharmaceutical Sciences,Drug Formulation Research,Polymer Science,Predictive Modeling in Pharma,Drug Development Tools,Biopharmaceuticals
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy >=1.15
+Requires-Dist: pandas >=1.0
+Requires-Dist: scipy >=1.4
+Requires-Dist: openpyxl >=3.0
+Provides-Extra: examples
+Requires-Dist: matplotlib >=3.0 ; extra == 'examples'
+

{cosmopharm-0.0.21.dist-info → cosmopharm-0.0.23.dist-info}/RECORD

@@ -1,18 +1,18 @@
 cosmopharm/__init__.py,sha256=sdgLzbqylG8DDAJ5J96YiO4egn9xVJTx2uzaIZ8qj4g,68
 cosmopharm/components.py,sha256=yHbhgFvLt9VN0jcAsLLRb0vS9FXM06yM7Pc7UgBli4M,946
 cosmopharm/actmodels/__init__.py,sha256=9iH67yrdSaf10Fj8LwRikUDUMeMxsvUHRPEaWc3384k,59
-cosmopharm/actmodels/actmodel.py,sha256=ZCOTdk1NgT0SwkdxFgYeToqlVVUzeibsVXOCxW9gDjg,3090
-cosmopharm/actmodels/cosmo.py,sha256=gkZ6-D0b1EEdxXvAp1dM81gSX6uxpLprK8NhnKy88m4,3434
+cosmopharm/actmodels/actmodel.py,sha256=69jluNR7Tb4BHwtkCQLI3NQ_0AEZcTDM69IdRPz9--w,5072
+cosmopharm/actmodels/cosmo.py,sha256=BoO_Yny_UUr8CxUuu8uuwR5kg3eR3NXKomKH1zsbm78,4372
 cosmopharm/equilibrium/__init__.py,sha256=5NsIbQEwELjeeoFEiWelnzHnhTzt5zsBh3r5icn_AIQ,44
-cosmopharm/equilibrium/lle.py,sha256=TvD4EV0bsbIO7PQdLnWWP0BvyiqmPz5kdeTyjLNtt4o,3343
-cosmopharm/equilibrium/sle.py,sha256=K1F2YQhK0GB35B0FuV-BXuY-D05apIeTpktLWvOul7o,9017
+cosmopharm/equilibrium/lle.py,sha256=k3ub2BXSpocY6TPsxLNkwSp8sAhU6LVsHEx84ptsKio,5470
+cosmopharm/equilibrium/sle.py,sha256=rIbNcvLQ9O5rvAssjxp4anahlUtxE3HMBB8s-rRVV-o,10963
 cosmopharm/utils/__init__.py,sha256=qfUPovmZ9ukj6ZbTfndUOH6EX0ZrzRNjLZEDIVS8UvM,113
 cosmopharm/utils/convert.py,sha256=V-7jY-Sb7C38N5bQcp1c27EOiVJfriP6zRbLAIKgrdE,2470
 cosmopharm/utils/helpers.py,sha256=D2Zx9P0ywWWl2XQtzC6e5ek2CrudBIncfAIp_7vQnC0,1430
 cosmopharm/utils/lle_scanner.py,sha256=So9FCxLLcHmBkuF6zggMo3W3gFBocEmuRzyxVGy69JM,6587
 cosmopharm/utils/spacing.py,sha256=vtM9b4wodpFGkZFGGLhiSXT51Zl6fNK2Og4oRcbLFH4,9222
-cosmopharm-0.0.21.dist-info/LICENSE,sha256=25ZCycfBgonIECGYnZTy72eJVfzcHCEOz3DM9sTx7do,1162
-cosmopharm-0.0.21.dist-info/METADATA,sha256=hGj9QrsqF3hBu1LT6NRuJnhkqSKvxxg_2xptCUCVawY,5705
-cosmopharm-0.0.21.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-cosmopharm-0.0.21.dist-info/top_level.txt,sha256=MGniVgvs1yq4sn6HQ7ErDVYV_g3st3Fs8TTFHOJVQ9I,11
-cosmopharm-0.0.21.dist-info/RECORD,,
+cosmopharm-0.0.23.dist-info/LICENSE,sha256=25ZCycfBgonIECGYnZTy72eJVfzcHCEOz3DM9sTx7do,1162
+cosmopharm-0.0.23.dist-info/METADATA,sha256=RIEg2FeVCKo7RTwxx7PIgOIkjWC1hH5LRHklyaP-Ywc,1851
+cosmopharm-0.0.23.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cosmopharm-0.0.23.dist-info/top_level.txt,sha256=MGniVgvs1yq4sn6HQ7ErDVYV_g3st3Fs8TTFHOJVQ9I,11
+cosmopharm-0.0.23.dist-info/RECORD,,

{cosmopharm-0.0.21.dist-info → cosmopharm-0.0.23.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

cosmopharm-0.0.21.dist-info/METADATA

@@ -1,118 +0,0 @@
-Metadata-Version: 2.1
-Name: cosmopharm
-Version: 0.0.21
-Summary: Predictive modeling for drug-polymer compatibility in pharmaceutical formulations using COSMO-SAC.
-Home-page: https://github.com/ivanantolo/cosmopharm,
-Author: Ivan Antolovic
-Author-email: Ivan.Antolovic@tu-berlin.de
-Maintainer: Martin Klajmon
-Maintainer-email: Martin.Klajmon@vscht.cz
-License: MIT
-Keywords: Drug-Polymer Compatibility,Amorphous Solid Dispersions,Pharmaceutical Formulation,COSMO-SAC Model,Solubility Prediction,Miscibility Analysis,Phase Behavior Prediction,Pharmaceutical Sciences,Drug Formulation Research,Polymer Science,Predictive Modeling in Pharma,Drug Development Tools,Biopharmaceuticals
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Science/Research
-Classifier: Intended Audience :: Healthcare Industry
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Education
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Classifier: Topic :: Scientific/Engineering :: Chemistry
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy >=1.15
-Requires-Dist: pandas >=1.0
-Requires-Dist: scipy >=1.4
-Requires-Dist: openpyxl >=3.0
-Provides-Extra: examples
-Requires-Dist: matplotlib >=3.0 ; extra == 'examples'
-
-# COSMOPharm
-
-<p align="center">
-  <img src="https://github.com/usnistgov/COSMOSAC/raw/master/JCTC2020.PNG" alt="TOC Figure" width="500">
-</p>
-
-COSMOPharm is a Python package designed for predictive modeling of drug-polymer compatibility and drug-solubility in common solvents. It leverages the COSMO-SAC (Conductor-like Screening Model Segment Activity Coefficient) model, offering a robust platform for solubility, miscibility, and phase behavior prediction in drug formulation processes.
-
-## Features
-
-- **Compatibility Prediction**: Predict drug-polymer compatibility using the open-source COSMO-SAC model.
-- **Solubility Calculation**: Guide polymer selection for drug formulations by calculating drug-polymer solubilities.
-- **Miscibility and Phase Behavior Analysis**: Understand drug-polymer miscibility and phase behavior under various conditions.
-- **User-friendly Interface**: Facilitate research with easy-to-use functions and comprehensive documentation.
-
-## Associated Research
-
-The development of COSMOPharm is closely tied to ongoing research aimed at enhancing the understanding and application of COSMO-SAC models in drug formulation. A forthcoming manuscript detailing the theoretical foundations and empirical validations of the models used in this package will provide comprehensive insights into the work COSMOPharm supports.
-
-**Note:** A related publication, provided as an example of the research context, can be found [here](https://dx.doi.org/10.1021/acs.jctc.9b01016). This link will be updated to directly point to our specific manuscript upon its publication, enabling users to delve deeper into the scientific basis and applications of COSMOPharm.
-
-## Installation
-
-Install COSMOPharm with pip:
-
-`pip install cosmopharm`
-
-Ensure you have installed the cCOSMO library as per instructions on the [COSMOSAC GitHub page](https://github.com/usnistgov/COSMOSAC).
-
-## Quick Start
-
-This minimal example demonstrates how to use COSMOPharm to calculate solubility and miscibility of a drug with a polymer:
-
-```python
-import cCOSMO
-from cosmopharm import SLE, COSMOSAC
-from cosmopharm.utils import create_components, read_params
-
-# Define components - replace 'DrugName' and 'PolymerName' with your actual component names
-names = ['DrugName', 'PolymerName']
-params_file = "path/to/your/params.xlsx"
-
-# Load parameters and create components
-parameters = read_params(params_file)
-components = create_components(names, parameters)
-
-# Initialize COSMO-SAC model - replace paths with your local paths to COSMO profiles
-db = cCOSMO.DelawareProfileDatabase(
-    "path/to/your/complist/complist.txt",
-    "path/to/your/profiles/")
-
-for name in names:
-    iden = db.normalize_identifier(name)
-    db.add_profile(iden)
-COSMO = cCOSMO.COSMO3(names, db)
-
-# Setup the COSMO-SAC model with components
-model = COSMOSAC(COSMO, components=components)
-
-# Calculate solubility (SLE)
-sle = SLE(solute=components[0], solvent=components[1], actmodel=model)
-solubility = sle.solubility(mix='real')
-
-# Output the solubility
-print(solubility[['T', 'w', 'x']].to_string(index=False))
-```
-
-Replace 'DrugName', 'PolymerName', and file paths with your actual data and files. This example provides a straightforward demonstration of calculating the real solubility of a drug in a polymer using COSMOPharm.
-
-## Contributing
-
-Contributions are welcome! Please refer to our [GitHub repository](https://github.com/ivanantolo/cosmopharm) for more information.
-
-## Citation
-
-If you use COSMOPharm in your research, kindly cite our work. Citation details are available in [CITATION.md](https://github.com/ivanantolo/cosmopharm/CITATION.md).
-
-## License
-
-COSMOPharm is released under the MIT License. For more details, see the [LICENSE](https://github.com/ivanantolo/cosmopharm/LICENSE) file.