rdworks 0.47.1__py3-none-any.whl → 0.49.1__py3-none-any.whl

rdworks/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.47.1'
+__version__ = '0.49.1'
 
 from rdworks.conf    import Conf
 from rdworks.mol     import Mol
@@ -25,10 +25,11 @@ __rdkit_version__ = rdkit.rdBase.rdkitVersion
 
 rdkit_logger = rdkit.RDLogger.logger().setLevel(rdkit.RDLogger.CRITICAL)
 
-main_logger = logging.getLogger()
-main_logger.setLevel(logging.INFO) # level: DEBUG < INFO < WARNING < ERROR < CRITICAL
-logger_formatter = logging.Formatter(fmt='%(asctime)s %(levelname)s %(message)s', 
-                                     datefmt='%Y-%m-%d %H:%M:%S')
-logger_ch = logging.StreamHandler()
-logger_ch.setFormatter(logger_formatter)
-main_logger.addHandler(logger_ch)
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO) # level: DEBUG < INFO < WARNING < ERROR < CRITICAL
+
+logger_stream = logging.StreamHandler() # sys.stdout or sys.stderr
+logger_format = logging.Formatter(fmt='%(asctime)s %(levelname)s %(message)s', 
+                                  datefmt='%Y-%m-%d %H:%M:%S')
+logger_stream.setFormatter(logger_format)
+logger.addHandler(logger_stream)

rdworks/ionized.py

@@ -1,4 +1,5 @@
 import importlib.resources
+from types import SimpleNamespace
 import pandas as pd
 
 from rdkit import Chem
@@ -6,6 +7,11 @@ from rdkit import Chem
 # adapted from https://github.com/dptech-corp/Uni-pKa/enumerator
 
 class IonizedStates:
+    """Knowledge-based enumeration of (de)protonated states"""
+
+    smarts_path = importlib.resources.files('rdworks.predefined.ionized')
+    ionization_patterns = pd.read_csv(smarts_path / 'simple_smarts_pattern.csv')
+    
     # Unreasonable chemical structures
     unreasonable_patterns = [
         Chem.MolFromSmarts(s) for s in [
@@ -31,67 +37,38 @@ class IonizedStates:
             "[N+1](=O)-[O]-[H]",
         ]]
 
-    smarts_path = importlib.resources.files('rdworks.predefined.ionized')
-    protonation_patterns = pd.read_csv(smarts_path / 'simple_smarts_pattern.csv')
 
-    def __init__(self, smiles:str):
+    def __init__(self, smiles: str, charge_min: int = -2, charge_max: int = 2):
         self.smiles = Chem.CanonSmiles(smiles)
+        self.charge_max = charge_max
+        self.charge_min = charge_min
+
         self.rdmol = Chem.MolFromSmiles(self.smiles)
         self.rdmol_H = Chem.AddHs(self.rdmol)
         self.charge = Chem.GetFormalCharge(self.rdmol_H)
-        self.charge_max =  2
-        self.charge_min = -2
+        
         # initial states
         self.states = {self.smiles : (self.rdmol_H, self.charge)}
-        # initial protonation sites
-        self.protonation_sites = {self.smiles : self.set_protonation_sites(self.smiles)}
-        # generate initial states
-        self.protonate(self.smiles)
+        
+        # initial ionization sites
+        self.sites = {self.smiles: self.set_ionization_sites(self.smiles)}
 
-    
-    def get_protonation_sites(self) -> dict:
-        return self.protonation_sites
+        # pKa pairs: 
+        # HA(acid) + H2O == A-(base) + H3O+ or HA+(acid) + H2O == A(base) + H3O+
+        self.pairs = []
 
-    
-    def get_states_by_charge(self) -> dict:
+        # iteratively build an ensemble of ionized states
         self.ensemble()
-        data = {}
-        for smiles, (romol, charge) in self.states.items():
-            if charge in data:
-                data[charge].append(smiles)
-            else:
-                data[charge] = [smiles]
 
-        return data
-
-    def get_states(self) -> list:
-        return [smiles for smiles in self.states]
-    
-
-    def get_states_mol(self) -> list[Chem.Mol]:
-        return [romol for smiles, (romol, charge) in self.states.items()]
-    
-
-    def get_num_states(self) -> int:
-        return len(self.states)
 
     
     @staticmethod
-    def clean_smiles(rdmol:Chem.Mol) -> str:
-        Chem.SanitizeMol(rdmol)
-        rdmol = Chem.MolFromSmiles(Chem.MolToSmiles(rdmol))
-        rdmol_H = Chem.AddHs(rdmol)
-        rdmol = Chem.RemoveHs(rdmol_H)
-        return Chem.CanonSmiles(Chem.MolToSmiles(rdmol))
-
-
-    @staticmethod
-    def set_protonation_sites(smiles:str) -> tuple:
+    def set_ionization_sites(smiles: str) -> tuple:
         subject = Chem.MolFromSmiles(smiles)
         subject = Chem.AddHs(subject)
         charge = Chem.GetFormalCharge(subject)        
         indices = [] # atom indices of protonation/deprotonation site(s)
-        for i, name, smarts, smarts_index, acid_or_base in IonizedStates.protonation_patterns.itertuples():
+        for i, name, smarts, smarts_index, acid_or_base in IonizedStates.ionization_patterns.itertuples():
             pattern = Chem.MolFromSmarts(smarts)
             matches = subject.GetSubstructMatches(pattern)
             # returns a list of tuples, where each tuple contains the indices 
@@ -100,21 +77,34 @@ class IonizedStates:
             if len(matches) > 0:
                 smarts_index = int(smarts_index)
                 indices += [(match[smarts_index], acid_or_base) for match in matches]
+        
         return (list(set(indices)), subject, charge)
+    
+
+    @staticmethod
+    def clean_smiles(rdmol: Chem.Mol) -> str:
+        Chem.SanitizeMol(rdmol)
+        rdmol = Chem.MolFromSmiles(Chem.MolToSmiles(rdmol))
+        rdmol_H = Chem.AddHs(rdmol)
+        rdmol = Chem.RemoveHs(rdmol_H)
+        return Chem.CanonSmiles(Chem.MolToSmiles(rdmol))
 
 
     @staticmethod
-    def reasonable(romol:Chem.Mol) -> bool:
+    def reasonable(romol: Chem.Mol) -> bool:
         return all([len(romol.GetSubstructMatches(p)) == 0 for p in IonizedStates.unreasonable_patterns])
+    
 
-        
-    def protonate(self, smiles:str) -> int:
+    def ionize(self, smiles: str | None = None) -> int:
         num_added_states = 0
         
-        if smiles not in self.protonation_sites:
-            self.protonation_sites[smiles] = self.set_protonation_sites(smiles)   
+        if smiles is None:
+            smiles = self.smiles
+
+        if smiles not in self.sites:
+            self.sites[smiles] = self.set_ionization_sites(smiles)
         
-        (indices, subject, charge) = self.protonation_sites[smiles]
+        (indices, subject, charge) = self.sites[smiles]
         
         if (charge >= self.charge_max) or (charge <= self.charge_min):
             # formal charge will be increased or decreased by protonation/deprotonation
@@ -140,6 +130,9 @@ class IonizedStates:
                     edmol.RemoveAtom(bonded_H_indices[0])
             
             elif acid_or_base == 'B': # protonate
+                # note that protonation at tertiary nitrogen may results in stereoisomers
+                # current implementation ignores the stereochemistry
+                # use rdworks.complete_stereoisomers() function to complete the stereoisomers
                 B = edmol.GetAtomWithIdx(i)
                 assert B.GetAtomicNum() > 1, f"Cannot protonate an atom (idx={i}; {B.GetAtomicNum()})"
                 charge = B.GetFormalCharge() + 1
@@ -148,23 +141,57 @@ class IonizedStates:
                 B.SetNumExplicitHs(nH+1)
                 edmol = Chem.AddHs(edmol)
             
-            # Clean up and save SMILES
-            state_smiles = IonizedStates.clean_smiles(edmol)
-            state_mol = Chem.MolFromSmiles(state_smiles)
-            state_mol = Chem.AddHs(state_mol)
-            state_charge = Chem.GetFormalCharge(state_mol)
-            if self.reasonable(state_mol):
-                if state_smiles in self.states:
+            # clean up and save SMILES
+            ionized_smiles = IonizedStates.clean_smiles(edmol)
+            ionized_mol = Chem.MolFromSmiles(ionized_smiles)
+            ionized_mol = Chem.AddHs(ionized_mol)
+            ionized_charge = Chem.GetFormalCharge(ionized_mol)
+            if self.reasonable(ionized_mol):
+                if ionized_smiles in self.states:
                     continue
-                self.states[state_smiles] = (state_mol, state_charge)
+                self.states[ionized_smiles] = (ionized_mol, ionized_charge)
                 num_added_states += 1
+            
+                # store acid-base pair information for pKa
+                if acid_or_base == 'A':
+                    self.pairs.append((i, smiles, ionized_smiles))
+                elif acid_or_base == 'B':
+                    self.pairs.append((i, ionized_smiles, smiles))
 
         return num_added_states
-
+    
     
     def ensemble(self) -> None:
+        # populate initial states
+        self.ionize()
+
+        # propagate
         num_added_states = None       
         while num_added_states is None or num_added_states > 0:
-            states = self.states.copy()
+            states = self.states.copy() # dictionary
+            # self.ionize(smiles) below will change self.states
+            # so we cannot iterate self.states. Instead we will
+            # iterate over a copy of the self.states
             for smiles in states:
-                num_added_states = self.protonate(smiles)
+                num_added_states = self.ionize(smiles) 
+                
+    
+    def count(self) -> int:
+        return len(self.states)
+
+
+    def get_sites(self) -> dict:
+        return self.sites
+    
+    
+    def get_smiles(self) -> list[str]:
+        return [smiles for smiles in self.states]
+    
+
+    def get_rdmol(self) -> list[Chem.Mol]:
+        return [romol for smiles, (romol, charge) in self.states.items()]
+    
+
+    def get_pairs(self) -> list:
+        return self.pairs
+    

rdworks/mol.py

@@ -46,7 +46,8 @@ from rdworks.display import render_svg, render_png
 
 from scour.scour import scourString
 
-main_logger = logging.getLogger()
+
+logger = logging.getLogger(__name__)
 
 
 class Mol:
@@ -328,11 +329,7 @@ class Mol:
         return self
 
 
-    def make_confs(self, 
-                   n:int = 50, 
-                   method:str = 'ETKDG', 
-                   calculator:str | Callable = 'MMFF94',
-                   ) -> Self:
+    def make_confs(self, n: int = 50, method: str = 'ETKDG', **kwargs) -> Self:
         """Generates 3D conformers.
 
         Args:
@@ -348,12 +345,8 @@ class Mol:
             High-Quality Conformer Generation with CONFORGE: Algorithm and Performance Assessment. 
             J. Chem. Inf. Model. 63, 5549-5570 (2023).
         """
-        
-        # if n is None:
-        #     rot_bonds = rd_descriptor_f['RotBonds'](self.rdmol)
-        #     n = min(max(1, int(8.481 * (rot_bonds **1.642))), 1000)
-        # n = max(1, math.ceil(n * n_rel)) # ensures that n is at least 1
-        
+        verbose = kwargs.get('verbose', False)
+
         self.confs = []
 
         if method.upper() == 'ETKDG':
@@ -426,6 +419,7 @@ class Mol:
             os.remove(tmp_filename)
 
         # energy evaluations for ranking
+        calculator = kwargs.get('calculator', 'MMFF94')
         for conf in self.confs:
             conf.potential_energy(calculator) # default: MMFF94
         
@@ -436,8 +430,15 @@ class Mol:
         for conf in self.confs:
             conf.props.update({"E_rel(kcal/mol)": conf.props[sort_by] - lowest_energy})
 
+        # rename conformers
         self = self.rename()
 
+        if verbose:
+            rot_bonds = rd_descriptor_f['RotBonds'](self.rdmol)
+            nrb_suggested = int(8.481 * (rot_bonds **1.642))
+            logger.info(f"make_confs() rotatable bonds {rot_bonds} (suggested conformers {nrb_suggested}) generated {self.count()}")
+            logger.info(f"make_confs() updated potential energies E_tot(kcal/mol) and E_rel(kcal/mol) by {calculator}")
+
         return self
 
 
@@ -499,10 +500,15 @@ class Mol:
         Returns:
             Self: modified self.
         """
+        verbose = kwargs.get('verbose', False)
+
         if calculator is not None:
             # re-calculate potential energies
+            if verbose :
+                logger.info(f"sort_cons() calculate potential energy by {calculator}")
+
             for conf in self.confs:
-                PE = conf.potential_energy(calculator=calculator, **kwargs) # sets `E_tot(kcal/mol)`
+                PE = conf.potential_energy(calculator, **kwargs) # sets `E_tot(kcal/mol)`
 
         if all(['E_tot(kcal/mol)' in conf.props for conf in self.confs]):
             sort_by = 'E_tot(kcal/mol)'
@@ -767,7 +773,7 @@ class Mol:
                    cluster: bool | None =None,
                    k: int | None = None,
                    window: float | None = None,
-                   verbose: bool = False) -> Self:
+                   **kwargs) -> Self:
         """Drop conformers that meet some condition(s).
 
         Args:
@@ -792,6 +798,8 @@ class Mol:
             Self: modified self.    
         """
 
+        verbose = kwargs.get('verbose', False)
+
         reasons = [f'stereo flipped',  
                    f'unconverged', 
                    f'similar({similar_rmsd})',
@@ -805,13 +813,13 @@ class Mol:
             mask = [Chem.MolToSmiles(Chem.RemoveHs(_.rdmol)) == self.smiles for _ in self.confs]
             self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[0]:<{w}} -> {self.count()}')
+                logger.info(f'drop_confs() {mask.count(False):3d} {reasons[0]:<{w}} -> {self.count()}')
         
         if unconverged and self.count() > 0:
             mask = [_.props['Converged'] if 'Converged' in _.props else True for _ in self.confs]
             self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[1]:<{w}} -> {self.count()}')
+                logger.info(f'drop_confs() {mask.count(False):3d} {reasons[1]:<{w}} -> {self.count()}')
 
         if similar and self.count() > 1:
             # it is observed that there are essentially identical conformers 
@@ -831,7 +839,7 @@ class Mol:
             mask = [conf_idx in centroid_indices for conf_idx, conf in enumerate(self.confs)]
             self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[2]:<{w}} -> {self.count()}')
+                logger.info(f'drop_confs() {mask.count(False):3d} {reasons[2]:<{w}} -> {self.count()}')
 
             # note: it will retain the conformers with lower index
             # so, it should be sorted before dropping
@@ -856,9 +864,12 @@ class Mol:
             mask = [_.props['centroid'] if 'centroid' in _.props else True for _ in self.confs]
             self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[3]:<{w}} -> {self.count()}')
+                logger.info(f'drop_confs() {mask.count(False):3d} {reasons[3]:<{w}} -> {self.count()}')
 
         if (k or window) and self.count() > 0:
+            # confs must be sorted by energies
+            if not all(['E_rel(kcal/mol)' in _.props for _ in self.confs]):
+                self = self.sort_confs(**kwargs)
             if k:
                 mask_k = [i < k for i,_ in enumerate(self.confs)]
             else:
@@ -871,7 +882,7 @@ class Mol:
             mask = [(x and y) for (x,y) in zip(mask_k, mask_window)]
             self.confs = list(itertools.compress(self.confs, mask))
             if verbose:
-                main_logger.info(f'drop_confs() {mask.count(False):3d} {reasons[4]:<{w}} -> {self.count()}')
+                logger.info(f'drop_confs() {mask.count(False):3d} {reasons[4]:<{w}} -> {self.count()}')
         
         return self
 
@@ -974,7 +985,7 @@ class Mol:
     
 
     def torsion_energies(self,
-                         calculator: str | Callable,
+                         calculator: str | Callable = 'MMFF94',
                          torsion_key: int | None = None,
                          simplify: bool = True, 
                          fmax: float = 0.05,

rdworks/xtb/wrapper.py

@@ -14,7 +14,8 @@ from rdkit import Chem
 from rdkit.Geometry import Point3D
 
 
-logger = logging.getLogger()
+logger = logging.getLogger(__name__)
+
 
 # In ASE, the default energy unit is eV (electron volt).
 # It will be converted to kcal/mol
@@ -25,7 +26,7 @@ ev2kcalpermol = 23.060547830619026
 
 
 class GFN2xTB:
-    def __init__(self, molecule: Chem.Mol, ncores: int = 8):
+    def __init__(self, molecule: Chem.Mol, ncores: int | None = None):
         assert isinstance(molecule, Chem.Mol), "molecule is not rdkit.Chem.Mol type"
         assert molecule.GetConformer().Is3D(), "molecule is not a 3D conformer"
         assert self.is_xtb_ready(), "xtb is not accessible"
@@ -35,6 +36,9 @@ class GFN2xTB:
         self.symbols = [ atom.GetSymbol() for atom in molecule.GetAtoms() ]
         self.positions = molecule.GetConformer().GetPositions().tolist()
 
+        if ncores is None:
+            ncores = os.cpu_count()
+
         # Parallelisation
         os.environ['OMP_STACKSIZE'] = '4G'
         os.environ['OMP_NUM_THREADS'] = f'{ncores},1'
@@ -107,7 +111,7 @@ class GFN2xTB:
         Returns:
             str | None: version statement.
         """
-        if GFN2xTB.is_ready():
+        if GFN2xTB.is_xtb_ready():
             cmd = ['xtb', '--version']
             proc = subprocess.run(cmd, capture_output=True, text=True)
             assert proc.returncode == 0, "GFN2xTB() Error: xtb not available"
@@ -338,12 +342,9 @@ class GFN2xTB:
 
         with tempfile.TemporaryDirectory() as temp_dir: # tmpdir is a string
             workdir = Path(temp_dir)
-            if verbose:
-                logger.info(f'xtb.singlepoint workdir= {temp_dir}')
             
             geometry_input_path = workdir / 'geometry.xyz'
             xtbout_path = workdir / 'xtbout.json'
-            stdout_path = workdir / 'fort.6'
             wbo_path = workdir / 'wbo'
             geometry_output_path = workdir / 'xtbtopo.mol'
             
@@ -354,8 +355,6 @@ class GFN2xTB:
             
             options = ['--gfn', '2', '--json']
             
-            Gsolv = None
-            
             if water is not None and isinstance(water, str):
                 if water == 'gbsa':
                     options += ['--gbsa', 'H2O']
@@ -366,6 +365,9 @@ class GFN2xTB:
                 elif water == 'cpcmx' and self.is_cpcmx_option_ready():
                     options += ['--cpcmx', 'water']
 
+            if verbose:
+                logger.info(f"singlepoint() {' '.join(cmd+options)}")
+
             # 'xtbout.json', 'xtbrestart', 'xtbtopo.mol', 'charges', and 'wbo' files will be 
             # created in the current working directory.
             proc = subprocess.run(cmd + options, cwd=temp_dir, capture_output=True, text=True)
@@ -381,19 +383,20 @@ class GFN2xTB:
                 if xtbout_path.is_file():
                     with open(xtbout_path, 'r') as f:
                         datadict = json.load(f) # takes the file object as input
+
+                Gsolv = None
                                  
-                if (water is not None) and (Gsolv is None) and stdout_path.is_file():
+                if water is not None:
                     #  Free Energy contributions:                       [Eh]        [kcal/mol]
                     # -------------------------------------------------------------------------
                     #  solvation free energy (dG_solv):             -0.92587E-03    -0.58099
                     #  gas phase energy (E)                         -0.52068E+01
                     # -------------------------------------------------------------------------
                     #  total free energy (dG)                       -0.52077E+01
-                    with open(stdout_path, 'r') as f:
-                        for line in f:
-                            if 'solvation free energy' in line:
-                                m = re.search(r"solvation free energy \(dG_solv\)\:\s+[-+]?\d*\.?\d+E[-+]?\d*\s+(?P<kcalpermol>[-+]?\d*\.?\d+)", line)
-                                Gsolv = float(m.group('kcalpermol'))
+                    for line in proc.stdout.splitlines():
+                        if 'solvation free energy' in line:
+                            m = re.search(r"solvation free energy \(dG_solv\)\:\s+[-+]?\d*\.?\d+E[-+]?\d*\s+(?P<kcalpermol>[-+]?\d*\.?\d+)", line)
+                            Gsolv = float(m.group('kcalpermol'))
                 
                 Wiberg_bond_orders = self.load_wbo(wbo_path)
 
@@ -429,8 +432,6 @@ class GFN2xTB:
         """
         with tempfile.TemporaryDirectory() as temp_dir: # tmpdir is a string
             workdir = Path(temp_dir)
-            if verbose:
-                logger.info(f'xtb.optimize workdir= {temp_dir}')
             
             geometry_input_path = workdir / 'geometry.xyz'
             xtbout_path = workdir / 'xtbout.json'
@@ -452,6 +453,9 @@ class GFN2xTB:
                 elif water == 'cpcmx':
                     logger.warning('optimize with --cpcmx option is not implemented in xtb yet')
 
+            if verbose:
+                logger.info(f"optimize() {' '.join(cmd+options)}")
+
             proc = subprocess.run(cmd + options, cwd=temp_dir, capture_output=True, text=True)
 
             if proc.returncode == 0 and xtbout_path.is_file():
@@ -523,4 +527,4 @@ class GFN2xTB:
                 with open(xtb_esp_dat, 'r') as f:
                     pass
         
-        return None
+        return None

{rdworks-0.47.1.dist-info → rdworks-0.49.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdworks
-Version: 0.47.1
+Version: 0.49.1
 Summary: Routine tasks built on RDKit and other tools
 Author-email: Sung-Hun Bae <sunghun.bae@gmail.com>
 Maintainer-email: Sung-Hun Bae <sunghun.bae@gmail.com>

{rdworks-0.47.1.dist-info → rdworks-0.49.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
-rdworks/__init__.py,sha256=CkKXxGhqvK8jzCxjOXnj2IOOvdHKpHE6ekjM5ZECSUw,1368
+rdworks/__init__.py,sha256=1teH6iycO-shzgeW5KwSDr-CH6CYybv2sDcrSNUBDW0,1391
 rdworks/conf.py,sha256=iQLb3Qg3pjGiiMVMJ5-d57BC1id3zxEhEGlhhrLrA_c,34162
 rdworks/descriptor.py,sha256=34T_dQ6g8v3u-ym8TLKbQtxIIV5TEo-d3pdedq3o-cg,2106
 rdworks/display.py,sha256=JR0gR26UpH-JCxVOaqXZCUj2MiGZSrx9Me87FncspVI,13469
-rdworks/ionized.py,sha256=5oIjMRpkX792RIpEEE2Ir96icfFaN_h21mSihhfQPAw,6713
+rdworks/ionized.py,sha256=_t-Ajssv1rytV4Y_KsSbxfnsBKqy-EusbhNUtaWcV6o,7681
 rdworks/matchedseries.py,sha256=A3ON4CUpQV159mu9VqgNiJ8uoQ9ePOry9d3ra4NCAgc,10377
-rdworks/mol.py,sha256=e62DYV8XeqLL1mBydbS881pSUfJjaeHxalG64CIant8,68133
+rdworks/mol.py,sha256=UPLLJbfn1cPhcedrGW7tL_bk1QpG3BfpjCOhop0tmBY,68663
 rdworks/mollibr.py,sha256=X4UBO6Ga-QmNS7RwUiaDYAx0Q5hnWs71yTkEpH02Qb4,37696
 rdworks/pka.py,sha256=NVJVfpcNEMlX5QRyLBgUM7GIT7VMjO-llAR4LWc8J2c,1656
 rdworks/readin.py,sha256=0bnVcZcAmSLqc6zu1mYcv0LdBv2agQfOpKGwpSRL9VE,11742
@@ -65,9 +65,9 @@ rdworks/predefined/misc/reactive-part-2.xml,sha256=0vNTMwWrrQmxBpbgbyRHx8sVs83cq
 rdworks/predefined/misc/reactive-part-3.xml,sha256=LgWHSEbRTVmgBoIO45xbTo1xQJs0Xu51j3JnIapRYo4,3094
 rdworks/predefined/misc/reactive.xml,sha256=syedoQ6VYUfRLnxy99ObuDniJ_a_WhrWAJbTKFfJ6VY,11248
 rdworks/xtb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rdworks/xtb/wrapper.py,sha256=NQgkdRKN5YEtv_UPYKWDijzMEs5v2kFrhUWHqiro7bE,22174
-rdworks-0.47.1.dist-info/licenses/LICENSE,sha256=UOkJSBqYyQUvtCp7a-vdCANeEcLE2dnTie_eB1By5SY,1074
-rdworks-0.47.1.dist-info/METADATA,sha256=w8BCgsWZ6AqzjSjZL1z4ker0-mwca09u5XiBsXa0ycw,1967
-rdworks-0.47.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rdworks-0.47.1.dist-info/top_level.txt,sha256=05C98HbvBK2axUBogC_hAT_CdpOeQYGnQ6vRAgawr8s,8
-rdworks-0.47.1.dist-info/RECORD,,
+rdworks/xtb/wrapper.py,sha256=Uv5XrC1gbWyVZiUJsoVwn6i76SPrtBCVSja0kOgcSWQ,22125
+rdworks-0.49.1.dist-info/licenses/LICENSE,sha256=UOkJSBqYyQUvtCp7a-vdCANeEcLE2dnTie_eB1By5SY,1074
+rdworks-0.49.1.dist-info/METADATA,sha256=3Z8TiRFULi-sddBb-_bhWh13MYWcjjopn5wnpUORX00,1967
+rdworks-0.49.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rdworks-0.49.1.dist-info/top_level.txt,sha256=05C98HbvBK2axUBogC_hAT_CdpOeQYGnQ6vRAgawr8s,8
+rdworks-0.49.1.dist-info/RECORD,,