Hugging Face's logo

Spaces:
guohanghui
/
rdkit
Sleeping

App Files Community
guohanghui commited on
Commit
caf4838
·
verified ·
1 Parent(s): f985030

Upload 15 files

Browse files
Files changed (15) hide show
  1. rdkit/mcp_output/README_MCP.md +217 -0
  2. rdkit/mcp_output/analysis.json +2809 -0
  3. rdkit/mcp_output/env_info.json +15 -0
  4. rdkit/mcp_output/mcp_logs/llm_statistics.json +11 -0
  5. rdkit/mcp_output/mcp_logs/run_log.json +74 -0
  6. rdkit/mcp_output/mcp_plugin/__init__.py +0 -0
  7. rdkit/mcp_output/mcp_plugin/__pycache__/adapter.cpython-310.pyc +0 -0
  8. rdkit/mcp_output/mcp_plugin/__pycache__/mcp_service.cpython-310.pyc +0 -0
  9. rdkit/mcp_output/mcp_plugin/adapter.py +249 -0
  10. rdkit/mcp_output/mcp_plugin/main.py +13 -0
  11. rdkit/mcp_output/mcp_plugin/mcp_service.py +54 -0
  12. rdkit/mcp_output/requirements.txt +11 -0
  13. rdkit/mcp_output/start_mcp.py +34 -0
  14. rdkit/mcp_output/tests_mcp/test_mcp_basic.py +49 -0
  15. rdkit/mcp_output/tests_smoke/test_smoke.py +29 -0
rdkit/mcp_output/README_MCP.md ADDED
@@ -0,0 +1,217 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # RDKit MCP Plugin
2
+
3
+ ## Overview
4
+
5
+ The RDKit MCP Plugin is a comprehensive cheminformatics and machine learning toolkit designed for processing and analyzing chemical data. Built on a robust C++ core with Python bindings, RDKit provides tools for molecular representation, file parsing, substructure searching, molecular descriptor calculation, fingerprinting, 2D/3D visualization, and chemical reaction handling. It is widely used in computational chemistry, drug discovery, and materials science.
6
+
7
+ This plugin integrates RDKit's capabilities into a modular and extensible framework, enabling users to perform complex chemical informatics tasks efficiently.
8
+
9
+ ## Features
10
+
11
+ - **Molecular Representation**: Support for SMILES, Molfile, and other formats.
12
+ - **Substructure Searching**: Advanced SMARTS-based querying.
13
+ - **Molecular Descriptors**: Calculation of chemical properties and fingerprints.
14
+ - **Visualization**: 2D and 3D molecular rendering.
15
+ - **Chemical Reactions**: Reaction handling and enumeration.
16
+ - **Machine Learning Integration**: Tools for cheminformatics-driven ML workflows.
17
+ - **Extensibility**: Modular design for integration with Python, PostgreSQL, and JavaScript.
18
+
19
+ ## Installation
20
+
21
+ ### Prerequisites
22
+
23
+ - Python 3.6 or higher
24
+ - C++ compiler (for building from source)
25
+ - Required Python libraries: `numpy`, `pandas`, `matplotlib`, `scipy`
26
+ - Optional Python libraries: `pillow`, `pytest`, `jupyter`
27
+
28
+ ### Installation via PyPI
29
+
30
+ To install the RDKit MCP Plugin using pip:
31
+
32
+ ```
33
+ pip install rdkit
34
+ ```
35
+
36
+ ### Installation from Source
37
+
38
+ 1. Clone the repository:
39
+ ```
40
+ git clone https://github.com/rdkit/rdkit.git
41
+ cd rdkit
42
+ ```
43
+
44
+ 2. Build the project:
45
+ ```
46
+ mkdir build
47
+ cd build
48
+ cmake ..
49
+ make
50
+ ```
51
+
52
+ 3. Install the Python bindings:
53
+ ```
54
+ make install
55
+ ```
56
+
57
+ 4. Verify the installation:
58
+ ```
59
+ python -c "import rdkit; print(rdkit.__version__)"
60
+ ```
61
+
62
+ ### PostgreSQL Integration
63
+
64
+ To enable the PostgreSQL chemical cartridge:
65
+
66
+ 1. Install PostgreSQL and its development libraries.
67
+ 2. Build the cartridge:
68
+ ```
69
+ cd Code/PgSQL/rdkit
70
+ make
71
+ make install
72
+ ```
73
+ 3. Configure PostgreSQL to load the RDKit extension:
74
+ ```
75
+ CREATE EXTENSION rdkit;
76
+ ```
77
+
78
+ ## Usage
79
+
80
+ RDKit can be used via Python or C++. Below are some common workflows:
81
+
82
+ ### Python Example
83
+
84
+ ```python
85
+ from rdkit import Chem
86
+ from rdkit.Chem import AllChem, Draw
87
+
88
+ # Create a molecule from SMILES
89
+ mol = Chem.MolFromSmiles('c1ccccc1')
90
+
91
+ # Add hydrogens
92
+ mol_with_h = Chem.AddHs(mol)
93
+
94
+ # Generate 2D coordinates
95
+ AllChem.Compute2DCoords(mol_with_h)
96
+
97
+ # Visualize the molecule
98
+ img = Draw.MolToImage(mol_with_h)
99
+ img.show()
100
+ ```
101
+
102
+ ### C++ Example
103
+
104
+ ```cpp
105
+ #include <GraphMol/SmilesParse/SmilesParse.h>
106
+ #include <GraphMol/MolOps.h>
107
+ #include <GraphMol/Depictor/RDDepictor.h>
108
+
109
+ using namespace RDKit;
110
+
111
+ int main() {
112
+ ROMol *mol = SmilesToMol("c1ccccc1");
113
+ MolOps::addHs(*mol);
114
+ RDDepict::compute2DCoords(*mol);
115
+ delete mol;
116
+ return 0;
117
+ }
118
+ ```
119
+
120
+ ## Available Tools and Endpoints
121
+
122
+ ### Command-Line Tools
123
+
124
+ 1. **FeatFinderCLI**
125
+ - **Description**: Command-line interface for finding chemical features in molecules.
126
+ - **Usage**:
127
+ ```
128
+ python -m rdkit.Chem.FeatFinderCLI --input <input_file> --output <output_file>
129
+ ```
130
+
131
+ 2. **run_python_tests**
132
+ - **Description**: Command-line tool for running Python tests in the RDKit repository.
133
+ - **Usage**:
134
+ ```
135
+ python -m Scripts.run_python_tests
136
+ ```
137
+
138
+ ### Python Modules
139
+
140
+ - **`rdkit.Chem`**: Core functionality for molecular operations.
141
+ - **`rdkit.Chem.AllChem`**: Advanced features like conformer generation and reaction handling.
142
+ - **`rdkit.Chem.Draw`**: Visualization tools for 2D molecular rendering.
143
+ - **`rdkit.DataStructs`**: Fingerprints and similarity calculations.
144
+ - **`rdkit.ML`**: Machine learning utilities for cheminformatics.
145
+
146
+ ### PostgreSQL Cartridge
147
+
148
+ - **`rdkit`**: PostgreSQL extension for chemical data storage and querying.
149
+ - **Functions**:
150
+ - `mol_from_smiles(smiles)`
151
+ - `mol_to_smiles(mol)`
152
+ - `substruct_match(mol, query)`
153
+
154
+ ## Notes and Troubleshooting
155
+
156
+ ### Common Issues
157
+
158
+ 1. **Installation Errors**:
159
+ Ensure all dependencies are installed, including a compatible C++ compiler and Python version.
160
+
161
+ 2. **Visualization Issues**:
162
+ If molecular images do not render, ensure `pillow` is installed:
163
+ ```
164
+ pip install pillow
165
+ ```
166
+
167
+ 3. **PostgreSQL Cartridge Errors**:
168
+ Verify that the RDKit extension is properly installed and loaded in PostgreSQL.
169
+
170
+ ### Debugging Tips
171
+
172
+ - Use `pytest` to run unit tests:
173
+ ```
174
+ pytest
175
+ ```
176
+ - Check the RDKit version:
177
+ ```
178
+ python -c "import rdkit; print(rdkit.__version__)"
179
+ ```
180
+ - Enable verbose logging for debugging:
181
+ ```python
182
+ from rdkit import RDLogger
183
+ RDLogger.EnableLog('rdApp.*')
184
+ ```
185
+
186
+ ## Contributing
187
+
188
+ Contributions to the RDKit MCP Plugin are welcome! Please follow these steps:
189
+
190
+ 1. Fork the repository.
191
+ 2. Create a feature branch:
192
+ ```
193
+ git checkout -b feature-name
194
+ ```
195
+ 3. Commit your changes:
196
+ ```
197
+ git commit -m "Add feature description"
198
+ ```
199
+ 4. Push to your fork:
200
+ ```
201
+ git push origin feature-name
202
+ ```
203
+ 5. Open a pull request.
204
+
205
+ ## License
206
+
207
+ RDKit is licensed under the BSD license. See the `LICENSE` file for details.
208
+
209
+ ## Resources
210
+
211
+ - [RDKit Documentation](https://www.rdkit.org/docs/)
212
+ - [GitHub Repository](https://github.com/rdkit/rdkit)
213
+ - [PostgreSQL Cartridge Guide](https://www.rdkit.org/docs/Cartridge.html)
214
+
215
+ ## Acknowledgments
216
+
217
+ RDKit is developed and maintained by a dedicated community of contributors. Special thanks to the open-source community for their support and contributions.
rdkit/mcp_output/analysis.json ADDED
@@ -0,0 +1,2809 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "summary": {
3
+ "repository_url": "https://github.com/rdkit/rdkit",
4
+ "summary": "Imported via zip fallback, file count: 883",
5
+ "file_tree": {
6
+ ".azure-pipelines/linux_build.yml": {
7
+ "size": 3293
8
+ },
9
+ ".azure-pipelines/linux_build_cartridge.yml": {
10
+ "size": 1987
11
+ },
12
+ ".azure-pipelines/linux_build_fuzzer.yml": {
13
+ "size": 2219
14
+ },
15
+ ".azure-pipelines/linux_build_java.yml": {
16
+ "size": 2191
17
+ },
18
+ ".azure-pipelines/linux_build_limitexternal.yml": {
19
+ "size": 2586
20
+ },
21
+ ".azure-pipelines/linux_build_py311.yml": {
22
+ "size": 3159
23
+ },
24
+ ".azure-pipelines/mac_build.yml": {
25
+ "size": 3817
26
+ },
27
+ ".azure-pipelines/mac_build_java.yml": {
28
+ "size": 3455
29
+ },
30
+ ".azure-pipelines/vs_build.yml": {
31
+ "size": 2687
32
+ },
33
+ ".azure-pipelines/vs_build_dll.yml": {
34
+ "size": 2383
35
+ },
36
+ ".azure-pipelines/vs_build_swig.yml": {
37
+ "size": 2312
38
+ },
39
+ ".github/ISSUE_TEMPLATE.md": {
40
+ "size": 980
41
+ },
42
+ ".github/ISSUE_TEMPLATE/bug_report.md": {
43
+ "size": 1401
44
+ },
45
+ ".github/ISSUE_TEMPLATE/feature_request.md": {
46
+ "size": 1257
47
+ },
48
+ ".github/PULL_REQUEST_TEMPLATE.md": {
49
+ "size": 188
50
+ },
51
+ ".github/workflows/close_stale_issues.yml": {
52
+ "size": 1016
53
+ },
54
+ ".github/workflows/templates_updater.yml": {
55
+ "size": 2505
56
+ },
57
+ ".travis.yml": {
58
+ "size": 2789
59
+ },
60
+ "CMakeLists.txt": {
61
+ "size": 27859
62
+ },
63
+ "Code/CMakeLists.txt": {
64
+ "size": 928
65
+ },
66
+ "Code/Catalogs/CMakeLists.txt": {
67
+ "size": 293
68
+ },
69
+ "Code/ChemicalFeatures/CMakeLists.txt": {
70
+ "size": 457
71
+ },
72
+ "Code/ChemicalFeatures/Wrap/CMakeLists.txt": {
73
+ "size": 357
74
+ },
75
+ "Code/ChemicalFeatures/Wrap/testFeatures.py": {
76
+ "size": 4178
77
+ },
78
+ "Code/DataManip/CMakeLists.txt": {
79
+ "size": 35
80
+ },
81
+ "Code/DataManip/MetricMatrixCalc/CMakeLists.txt": {
82
+ "size": 245
83
+ },
84
+ "Code/DataManip/MetricMatrixCalc/Wrap/CMakeLists.txt": {
85
+ "size": 257
86
+ },
87
+ "Code/DataManip/MetricMatrixCalc/Wrap/testMatricCalc.py": {
88
+ "size": 3770
89
+ },
90
+ "Code/DataStructs/CMakeLists.txt": {
91
+ "size": 1335
92
+ },
93
+ "Code/DataStructs/Wrap/CMakeLists.txt": {
94
+ "size": 864
95
+ },
96
+ "Code/DataStructs/Wrap/testBV.py": {
97
+ "size": 9054
98
+ },
99
+ "Code/DataStructs/Wrap/testDiscreteValueVect.py": {
100
+ "size": 7786
101
+ },
102
+ "Code/DataStructs/Wrap/testFPB.py": {
103
+ "size": 11815
104
+ },
105
+ "Code/DataStructs/Wrap/testRealValueVect.py": {
106
+ "size": 3108
107
+ },
108
+ "Code/DataStructs/Wrap/testSparseIntVect.py": {
109
+ "size": 5472
110
+ },
111
+ "Code/Demos/RDKit/Basement/xpcom/demo/rd.js": {
112
+ "size": 24
113
+ },
114
+ "Code/Demos/RDKit/Basement/xpcom/demo/sorttable.js": {
115
+ "size": 7727
116
+ },
117
+ "Code/Demos/RDKit/Draw/drawmol.js": {
118
+ "size": 3843
119
+ },
120
+ "Code/Demos/RDKit/GettingStarted/CMakeLists.txt": {
121
+ "size": 278
122
+ },
123
+ "Code/Demos/RDKit/MPI/rdkpympi.py": {
124
+ "size": 1752
125
+ },
126
+ "Code/Demos/boost/EBV_err/setup.py": {
127
+ "size": 1853
128
+ },
129
+ "Code/Demos/boost/EBV_err/test.py": {
130
+ "size": 837
131
+ },
132
+ "Code/Demos/boost/cross_mod_err/setup.py": {
133
+ "size": 1657
134
+ },
135
+ "Code/Demos/boost/cross_mod_err/test.py": {
136
+ "size": 637
137
+ },
138
+ "Code/Demos/boost/cross_module/readme.txt": {
139
+ "size": 67
140
+ },
141
+ "Code/Demos/boost/cross_module/setup.py": {
142
+ "size": 1490
143
+ },
144
+ "Code/Demos/boost/cross_module/test.py": {
145
+ "size": 204
146
+ },
147
+ "Code/Demos/boost/numpy/setup.py": {
148
+ "size": 1346
149
+ },
150
+ "Code/Demos/boost/numpy/test.py": {
151
+ "size": 275
152
+ },
153
+ "Code/Demos/boost/overloads/setup.py": {
154
+ "size": 1357
155
+ },
156
+ "Code/Demos/boost/overloads/test.py": {
157
+ "size": 202
158
+ },
159
+ "Code/Demos/boost/python_objs/setup.py": {
160
+ "size": 1374
161
+ },
162
+ "Code/Demos/boost/python_objs/test.py": {
163
+ "size": 939
164
+ },
165
+ "Code/Demos/boost/smartPtrsAndIters/setup.py": {
166
+ "size": 357
167
+ },
168
+ "Code/Demos/boost/smartPtrsAndIters/test.py": {
169
+ "size": 1375
170
+ },
171
+ "Code/DistGeom/CMakeLists.txt": {
172
+ "size": 797
173
+ },
174
+ "Code/DistGeom/Wrap/CMakeLists.txt": {
175
+ "size": 238
176
+ },
177
+ "Code/DistGeom/Wrap/rough_test.py": {
178
+ "size": 3502
179
+ },
180
+ "Code/Features/CMakeLists.txt": {
181
+ "size": 147
182
+ },
183
+ "Code/ForceField/CMakeLists.txt": {
184
+ "size": 2113
185
+ },
186
+ "Code/ForceField/MMFF/CMakeLists.txt": {
187
+ "size": 602
188
+ },
189
+ "Code/ForceField/UFF/CMakeLists.txt": {
190
+ "size": 143
191
+ },
192
+ "Code/ForceField/Wrap/CMakeLists.txt": {
193
+ "size": 276
194
+ },
195
+ "Code/ForceField/Wrap/testConstraints.py": {
196
+ "size": 11606
197
+ },
198
+ "Code/Fuzz/CMakeLists.txt": {
199
+ "size": 1369
200
+ },
201
+ "Code/Fuzz/README.md": {
202
+ "size": 2589
203
+ },
204
+ "Code/Geometry/CMakeLists.txt": {
205
+ "size": 978
206
+ },
207
+ "Code/Geometry/Wrap/CMakeLists.txt": {
208
+ "size": 338
209
+ },
210
+ "Code/Geometry/Wrap/testGeometry.py": {
211
+ "size": 27110
212
+ },
213
+ "Code/GraphMol/Abbreviations/CMakeLists.txt": {
214
+ "size": 496
215
+ },
216
+ "Code/GraphMol/Abbreviations/Wrap/CMakeLists.txt": {
217
+ "size": 259
218
+ },
219
+ "Code/GraphMol/Abbreviations/Wrap/testAbbreviations.py": {
220
+ "size": 8287
221
+ },
222
+ "Code/GraphMol/CIPLabeler/CMakeLists.txt": {
223
+ "size": 1410
224
+ },
225
+ "Code/GraphMol/CIPLabeler/Wrap/CMakeLists.txt": {
226
+ "size": 370
227
+ },
228
+ "Code/GraphMol/CIPLabeler/Wrap/pyCIPLabelWrapTest.py": {
229
+ "size": 4150
230
+ },
231
+ "Code/GraphMol/CIPLabeler/Wrap/pyCIPLabelsValidation.py": {
232
+ "size": 2574
233
+ },
234
+ "Code/GraphMol/CMakeLists.txt": {
235
+ "size": 6461
236
+ },
237
+ "Code/GraphMol/ChemReactions/CMakeLists.txt": {
238
+ "size": 2120
239
+ },
240
+ "Code/GraphMol/ChemReactions/Wrap/CMakeLists.txt": {
241
+ "size": 589
242
+ },
243
+ "Code/GraphMol/ChemReactions/Wrap/testEnumerations.py": {
244
+ "size": 26736
245
+ },
246
+ "Code/GraphMol/ChemReactions/Wrap/testReactionWrapper.py": {
247
+ "size": 52085
248
+ },
249
+ "Code/GraphMol/ChemReactions/Wrap/testSanitize.py": {
250
+ "size": 10493
251
+ },
252
+ "Code/GraphMol/ChemReactions/license.txt": {
253
+ "size": 1747
254
+ },
255
+ "Code/GraphMol/ChemTransforms/CMakeLists.txt": {
256
+ "size": 664
257
+ },
258
+ "Code/GraphMol/ChemTransforms/testData/query_file1.txt": {
259
+ "size": 900
260
+ },
261
+ "Code/GraphMol/ChemTransforms/testData/query_file2.txt": {
262
+ "size": 13
263
+ },
264
+ "Code/GraphMol/Depictor/CMakeLists.txt": {
265
+ "size": 1322
266
+ },
267
+ "Code/GraphMol/Depictor/Wrap/CMakeLists.txt": {
268
+ "size": 277
269
+ },
270
+ "Code/GraphMol/Depictor/Wrap/testDepictor.py": {
271
+ "size": 49121
272
+ },
273
+ "Code/GraphMol/Deprotect/CMakeLists.txt": {
274
+ "size": 510
275
+ },
276
+ "Code/GraphMol/Deprotect/Wrap/CMakeLists.txt": {
277
+ "size": 339
278
+ },
279
+ "Code/GraphMol/Deprotect/Wrap/rough_test.py": {
280
+ "size": 2493
281
+ },
282
+ "Code/GraphMol/Descriptors/CMakeLists.txt": {
283
+ "size": 2618
284
+ },
285
+ "Code/GraphMol/Descriptors/Wrap/CMakeLists.txt": {
286
+ "size": 369
287
+ },
288
+ "Code/GraphMol/Descriptors/Wrap/test3D.py": {
289
+ "size": 5518
290
+ },
291
+ "Code/GraphMol/Descriptors/Wrap/testMolDescriptors.py": {
292
+ "size": 31850
293
+ },
294
+ "Code/GraphMol/Descriptors/test3D.py": {
295
+ "size": 1312
296
+ },
297
+ "Code/GraphMol/Descriptors/test3D_old.py": {
298
+ "size": 3488
299
+ },
300
+ "Code/GraphMol/Descriptors/testSMWHIM.txt": {
301
+ "size": 35057
302
+ },
303
+ "Code/GraphMol/Descriptors/test_data/pmi.py": {
304
+ "size": 1453
305
+ },
306
+ "Code/GraphMol/Descriptors/test_data/whim.out.txt": {
307
+ "size": 261983
308
+ },
309
+ "Code/GraphMol/DetermineBonds/CMakeLists.txt": {
310
+ "size": 549
311
+ },
312
+ "Code/GraphMol/DetermineBonds/README.md": {
313
+ "size": 4077
314
+ },
315
+ "Code/GraphMol/DetermineBonds/Wrap/CMakeLists.txt": {
316
+ "size": 264
317
+ },
318
+ "Code/GraphMol/DetermineBonds/Wrap/testDetermineBonds.py": {
319
+ "size": 6092
320
+ },
321
+ "Code/GraphMol/DistGeomHelpers/CMakeLists.txt": {
322
+ "size": 716
323
+ },
324
+ "Code/GraphMol/DistGeomHelpers/Wrap/CMakeLists.txt": {
325
+ "size": 422
326
+ },
327
+ "Code/GraphMol/DistGeomHelpers/Wrap/testDistGeom.py": {
328
+ "size": 27889
329
+ },
330
+ "Code/GraphMol/EnumerateStereoisomers/CMakeLists.txt": {
331
+ "size": 542
332
+ },
333
+ "Code/GraphMol/EnumerateStereoisomers/Wrap/CMakeLists.txt": {
334
+ "size": 307
335
+ },
336
+ "Code/GraphMol/EnumerateStereoisomers/Wrap/testEnumerateStereoisomers.py": {
337
+ "size": 2932
338
+ },
339
+ "Code/GraphMol/FMCS/CMakeLists.txt": {
340
+ "size": 504
341
+ },
342
+ "Code/GraphMol/FMCS/Test/CMakeLists.txt": {
343
+ "size": 55
344
+ },
345
+ "Code/GraphMol/FMCS/Wrap/CMakeLists.txt": {
346
+ "size": 241
347
+ },
348
+ "Code/GraphMol/FMCS/Wrap/testFMCS.py": {
349
+ "size": 49244
350
+ },
351
+ "Code/GraphMol/FileParsers/CMakeLists.txt": {
352
+ "size": 4577
353
+ },
354
+ "Code/GraphMol/FileParsers/mol.py": {
355
+ "size": 1591
356
+ },
357
+ "Code/GraphMol/FilterCatalog/CMakeLists.txt": {
358
+ "size": 1355
359
+ },
360
+ "Code/GraphMol/FilterCatalog/Wrap/CMakeLists.txt": {
361
+ "size": 352
362
+ },
363
+ "Code/GraphMol/FilterCatalog/Wrap/rough_test.py": {
364
+ "size": 22284
365
+ },
366
+ "Code/GraphMol/FilterCatalog/update_pains.py": {
367
+ "size": 11951
368
+ },
369
+ "Code/GraphMol/Fingerprints/CMakeLists.txt": {
370
+ "size": 1478
371
+ },
372
+ "Code/GraphMol/Fingerprints/Wrap/CMakeLists.txt": {
373
+ "size": 492
374
+ },
375
+ "Code/GraphMol/Fingerprints/Wrap/testGenerators.py": {
376
+ "size": 17138
377
+ },
378
+ "Code/GraphMol/Fingerprints/Wrap/testMHFP.py": {
379
+ "size": 2011
380
+ },
381
+ "Code/GraphMol/ForceFieldHelpers/CMakeLists.txt": {
382
+ "size": 1155
383
+ },
384
+ "Code/GraphMol/ForceFieldHelpers/CrystalFF/CMakeLists.txt": {
385
+ "size": 174
386
+ },
387
+ "Code/GraphMol/ForceFieldHelpers/MMFF/CMakeLists.txt": {
388
+ "size": 370
389
+ },
390
+ "Code/GraphMol/ForceFieldHelpers/UFF/CMakeLists.txt": {
391
+ "size": 229
392
+ },
393
+ "Code/GraphMol/ForceFieldHelpers/Wrap/CMakeLists.txt": {
394
+ "size": 308
395
+ },
396
+ "Code/GraphMol/ForceFieldHelpers/Wrap/testHelpers.py": {
397
+ "size": 16410
398
+ },
399
+ "Code/GraphMol/FragCatalog/CMakeLists.txt": {
400
+ "size": 655
401
+ },
402
+ "Code/GraphMol/FragCatalog/Wrap/CMakeLists.txt": {
403
+ "size": 414
404
+ },
405
+ "Code/GraphMol/FragCatalog/Wrap/rough_test.py": {
406
+ "size": 7116
407
+ },
408
+ "Code/GraphMol/FragCatalog/test_data/funcGroups.txt": {
409
+ "size": 899
410
+ },
411
+ "Code/GraphMol/GeneralizedSubstruct/CMakeLists.txt": {
412
+ "size": 559
413
+ },
414
+ "Code/GraphMol/GeneralizedSubstruct/Wrap/CMakeLists.txt": {
415
+ "size": 294
416
+ },
417
+ "Code/GraphMol/GeneralizedSubstruct/Wrap/testGeneralizedSubstruct.py": {
418
+ "size": 7249
419
+ },
420
+ "Code/GraphMol/GenericGroups/CMakeLists.txt": {
421
+ "size": 389
422
+ },
423
+ "Code/GraphMol/MMPA/CMakeLists.txt": {
424
+ "size": 467
425
+ },
426
+ "Code/GraphMol/MMPA/Wrap/CMakeLists.txt": {
427
+ "size": 241
428
+ },
429
+ "Code/GraphMol/MMPA/Wrap/testMMPA.py": {
430
+ "size": 6191
431
+ },
432
+ "Code/GraphMol/MarvinParse/CMakeLists.txt": {
433
+ "size": 453
434
+ },
435
+ "Code/GraphMol/MolAlign/CMakeLists.txt": {
436
+ "size": 951
437
+ },
438
+ "Code/GraphMol/MolAlign/Wrap/CMakeLists.txt": {
439
+ "size": 279
440
+ },
441
+ "Code/GraphMol/MolAlign/Wrap/testMolAlign.py": {
442
+ "size": 21866
443
+ },
444
+ "Code/GraphMol/MolCatalog/CMakeLists.txt": {
445
+ "size": 471
446
+ },
447
+ "Code/GraphMol/MolCatalog/Wrap/CMakeLists.txt": {
448
+ "size": 253
449
+ },
450
+ "Code/GraphMol/MolCatalog/Wrap/rough_test.py": {
451
+ "size": 1258
452
+ },
453
+ "Code/GraphMol/MolChemicalFeatures/CMakeLists.txt": {
454
+ "size": 651
455
+ },
456
+ "Code/GraphMol/MolChemicalFeatures/Wrap/CMakeLists.txt": {
457
+ "size": 412
458
+ },
459
+ "Code/GraphMol/MolChemicalFeatures/Wrap/testChemicalFeatures.py": {
460
+ "size": 7145
461
+ },
462
+ "Code/GraphMol/MolChemicalFeatures/test_data/featDef.txt": {
463
+ "size": 164
464
+ },
465
+ "Code/GraphMol/MolChemicalFeatures/test_data/featDef2.txt": {
466
+ "size": 212
467
+ },
468
+ "Code/GraphMol/MolDraw2D/CMakeLists.txt": {
469
+ "size": 4853
470
+ },
471
+ "Code/GraphMol/MolDraw2D/Qt/CMakeLists.txt": {
472
+ "size": 2422
473
+ },
474
+ "Code/GraphMol/MolDraw2D/Qt/Demo/CMakeLists.txt": {
475
+ "size": 963
476
+ },
477
+ "Code/GraphMol/MolDraw2D/Qt/Wrap/CMakeLists.txt": {
478
+ "size": 288
479
+ },
480
+ "Code/GraphMol/MolDraw2D/Qt/Wrap/testMolDraw2DQt.py": {
481
+ "size": 2391
482
+ },
483
+ "Code/GraphMol/MolDraw2D/Wrap/CMakeLists.txt": {
484
+ "size": 277
485
+ },
486
+ "Code/GraphMol/MolDraw2D/Wrap/testMolDraw2D.py": {
487
+ "size": 36075
488
+ },
489
+ "Code/GraphMol/MolDraw2D/side_by_side_images.py": {
490
+ "size": 1851
491
+ },
492
+ "Code/GraphMol/MolDraw2D/test_dir/test_rdkit_draw.py": {
493
+ "size": 507
494
+ },
495
+ "Code/GraphMol/MolDraw2D/update_hash_codes.py": {
496
+ "size": 1387
497
+ },
498
+ "Code/GraphMol/MolEnumerator/CMakeLists.txt": {
499
+ "size": 552
500
+ },
501
+ "Code/GraphMol/MolEnumerator/Wrap/CMakeLists.txt": {
502
+ "size": 311
503
+ },
504
+ "Code/GraphMol/MolEnumerator/Wrap/rough_test.py": {
505
+ "size": 3160
506
+ },
507
+ "Code/GraphMol/MolHash/CMakeLists.txt": {
508
+ "size": 444
509
+ },
510
+ "Code/GraphMol/MolHash/Wrap/CMakeLists.txt": {
511
+ "size": 259
512
+ },
513
+ "Code/GraphMol/MolHash/Wrap/testMolHash.py": {
514
+ "size": 3564
515
+ },
516
+ "Code/GraphMol/MolInteractionFields/CMakeLists.txt": {
517
+ "size": 636
518
+ },
519
+ "Code/GraphMol/MolInteractionFields/Wrap/CMakeLists.txt": {
520
+ "size": 385
521
+ },
522
+ "Code/GraphMol/MolInteractionFields/Wrap/testMIF.py": {
523
+ "size": 13630
524
+ },
525
+ "Code/GraphMol/MolInterchange/CMakeLists.txt": {
526
+ "size": 1824
527
+ },
528
+ "Code/GraphMol/MolInterchange/Wrap/CMakeLists.txt": {
529
+ "size": 300
530
+ },
531
+ "Code/GraphMol/MolInterchange/Wrap/testMolInterchange.py": {
532
+ "size": 1746
533
+ },
534
+ "Code/GraphMol/MolInterchange/test_data/1000mols.json": {
535
+ "size": 524313
536
+ },
537
+ "Code/GraphMol/MolInterchange/test_data/test1.json": {
538
+ "size": 1339
539
+ },
540
+ "Code/GraphMol/MolInterchange/test_data/test2.json": {
541
+ "size": 1173
542
+ },
543
+ "Code/GraphMol/MolInterchange/test_data/test3.json": {
544
+ "size": 1232
545
+ },
546
+ "Code/GraphMol/MolProcessing/CMakeLists.txt": {
547
+ "size": 424
548
+ },
549
+ "Code/GraphMol/MolProcessing/Wrap/CMakeLists.txt": {
550
+ "size": 259
551
+ },
552
+ "Code/GraphMol/MolProcessing/Wrap/testMolProcessing.py": {
553
+ "size": 2079
554
+ },
555
+ "Code/GraphMol/MolStandardize/CMakeLists.txt": {
556
+ "size": 2652
557
+ },
558
+ "Code/GraphMol/MolStandardize/Wrap/CMakeLists.txt": {
559
+ "size": 396
560
+ },
561
+ "Code/GraphMol/MolStandardize/Wrap/testMolStandardize.py": {
562
+ "size": 75331
563
+ },
564
+ "Code/GraphMol/MolStandardize/test_data/acid_base_pairs2.txt": {
565
+ "size": 1458
566
+ },
567
+ "Code/GraphMol/MolStandardize/test_data/fragmentPatterns.txt": {
568
+ "size": 2039
569
+ },
570
+ "Code/GraphMol/MolStandardize/test_data/normalizations.txt": {
571
+ "size": 3062
572
+ },
573
+ "Code/GraphMol/MolTransforms/CMakeLists.txt": {
574
+ "size": 524
575
+ },
576
+ "Code/GraphMol/MolTransforms/Wrap/CMakeLists.txt": {
577
+ "size": 297
578
+ },
579
+ "Code/GraphMol/MolTransforms/Wrap/testMolTransforms.py": {
580
+ "size": 11262
581
+ },
582
+ "Code/GraphMol/PartialCharges/CMakeLists.txt": {
583
+ "size": 456
584
+ },
585
+ "Code/GraphMol/PartialCharges/Wrap/CMakeLists.txt": {
586
+ "size": 303
587
+ },
588
+ "Code/GraphMol/PartialCharges/Wrap/testPartialCharges.py": {
589
+ "size": 4308
590
+ },
591
+ "Code/GraphMol/PartialCharges/Wrap/test_data/halgren_out.txt": {
592
+ "size": 1362
593
+ },
594
+ "Code/GraphMol/RGroupDecomposition/CMakeLists.txt": {
595
+ "size": 1333
596
+ },
597
+ "Code/GraphMol/RGroupDecomposition/Wrap/CMakeLists.txt": {
598
+ "size": 548
599
+ },
600
+ "Code/GraphMol/RGroupDecomposition/Wrap/test_rgroups.py": {
601
+ "size": 46854
602
+ },
603
+ "Code/GraphMol/RGroupDecomposition/test_data/jm200186n.excerpt.out1.json": {
604
+ "size": 923
605
+ },
606
+ "Code/GraphMol/RGroupDecomposition/test_data/jm7b00306.excerpt.out1.json": {
607
+ "size": 740
608
+ },
609
+ "Code/GraphMol/RGroupDecomposition/test_data/simple1.out1.json": {
610
+ "size": 314
611
+ },
612
+ "Code/GraphMol/RGroupDecomposition/test_data/simple1.out2.json": {
613
+ "size": 413
614
+ },
615
+ "Code/GraphMol/RGroupDecomposition/test_data/simple2.out1.json": {
616
+ "size": 314
617
+ },
618
+ "Code/GraphMol/RGroupDecomposition/test_data/simple2.out2.json": {
619
+ "size": 144
620
+ },
621
+ "Code/GraphMol/RGroupDecomposition/test_data/simple3.out1.json": {
622
+ "size": 170
623
+ },
624
+ "Code/GraphMol/RGroupDecomposition/test_data/simple3.out2.json": {
625
+ "size": 170
626
+ },
627
+ "Code/GraphMol/RGroupDecomposition/test_data/simple3.out3.json": {
628
+ "size": 204
629
+ },
630
+ "Code/GraphMol/RGroupDecomposition/test_data/simple3.out4.json": {
631
+ "size": 360
632
+ },
633
+ "Code/GraphMol/RascalMCES/CMakeLists.txt": {
634
+ "size": 793
635
+ },
636
+ "Code/GraphMol/RascalMCES/Wrap/CMakeLists.txt": {
637
+ "size": 232
638
+ },
639
+ "Code/GraphMol/RascalMCES/Wrap/testRascalMCES.py": {
640
+ "size": 9282
641
+ },
642
+ "Code/GraphMol/ReducedGraphs/CMakeLists.txt": {
643
+ "size": 432
644
+ },
645
+ "Code/GraphMol/ReducedGraphs/Wrap/CMakeLists.txt": {
646
+ "size": 292
647
+ },
648
+ "Code/GraphMol/ReducedGraphs/Wrap/testReducedGraphs.py": {
649
+ "size": 1719
650
+ },
651
+ "Code/GraphMol/SLNParse/CMakeLists.txt": {
652
+ "size": 1833
653
+ },
654
+ "Code/GraphMol/SLNParse/Wrap/CMakeLists.txt": {
655
+ "size": 260
656
+ },
657
+ "Code/GraphMol/SLNParse/Wrap/testSLN.py": {
658
+ "size": 2588
659
+ },
660
+ "Code/GraphMol/ScaffoldNetwork/CMakeLists.txt": {
661
+ "size": 505
662
+ },
663
+ "Code/GraphMol/ScaffoldNetwork/Wrap/CMakeLists.txt": {
664
+ "size": 469
665
+ },
666
+ "Code/GraphMol/ScaffoldNetwork/Wrap/testPickleScaffoldNetwork.py": {
667
+ "size": 1288
668
+ },
669
+ "Code/GraphMol/ScaffoldNetwork/Wrap/testScaffoldNetwork.py": {
670
+ "size": 6250
671
+ },
672
+ "Code/GraphMol/ShapeHelpers/CMakeLists.txt": {
673
+ "size": 496
674
+ },
675
+ "Code/GraphMol/ShapeHelpers/Wrap/CMakeLists.txt": {
676
+ "size": 286
677
+ },
678
+ "Code/GraphMol/ShapeHelpers/Wrap/testShapeHelpers.py": {
679
+ "size": 3615
680
+ },
681
+ "Code/GraphMol/SmilesParse/CMakeLists.txt": {
682
+ "size": 3849
683
+ },
684
+ "Code/GraphMol/StructChecker/CMakeLists.txt": {
685
+ "size": 749
686
+ },
687
+ "Code/GraphMol/StructChecker/Wrap/CMakeLists.txt": {
688
+ "size": 240
689
+ },
690
+ "Code/GraphMol/StructChecker/Wrap/rough_test.py": {
691
+ "size": 7430
692
+ },
693
+ "Code/GraphMol/Subgraphs/CMakeLists.txt": {
694
+ "size": 611
695
+ },
696
+ "Code/GraphMol/Substruct/CMakeLists.txt": {
697
+ "size": 517
698
+ },
699
+ "Code/GraphMol/Substruct/UnitTestSubstruct.py": {
700
+ "size": 2714
701
+ },
702
+ "Code/GraphMol/Substruct/regress.txt": {
703
+ "size": 10
704
+ },
705
+ "Code/GraphMol/SubstructLibrary/CMakeLists.txt": {
706
+ "size": 941
707
+ },
708
+ "Code/GraphMol/SubstructLibrary/Wrap/CMakeLists.txt": {
709
+ "size": 374
710
+ },
711
+ "Code/GraphMol/SubstructLibrary/Wrap/rough_test.py": {
712
+ "size": 30302
713
+ },
714
+ "Code/GraphMol/SynthonSpaceSearch/CMakeLists.txt": {
715
+ "size": 1548
716
+ },
717
+ "Code/GraphMol/SynthonSpaceSearch/Wrap/CMakeLists.txt": {
718
+ "size": 280
719
+ },
720
+ "Code/GraphMol/SynthonSpaceSearch/Wrap/testSynthonSpaceSearch.py": {
721
+ "size": 7733
722
+ },
723
+ "Code/GraphMol/SynthonSpaceSearch/data/amide_space.txt": {
724
+ "size": 244
725
+ },
726
+ "Code/GraphMol/SynthonSpaceSearch/data/amide_space_dos.txt": {
727
+ "size": 252
728
+ },
729
+ "Code/GraphMol/SynthonSpaceSearch/data/amide_space_error.txt": {
730
+ "size": 248
731
+ },
732
+ "Code/GraphMol/SynthonSpaceSearch/data/amino_acid.txt": {
733
+ "size": 98
734
+ },
735
+ "Code/GraphMol/SynthonSpaceSearch/data/doebner_miller_space.txt": {
736
+ "size": 417
737
+ },
738
+ "Code/GraphMol/SynthonSpaceSearch/data/gregs_space_fail.txt": {
739
+ "size": 191
740
+ },
741
+ "Code/GraphMol/SynthonSpaceSearch/data/idorsia_toy_space_a.txt": {
742
+ "size": 18403
743
+ },
744
+ "Code/GraphMol/SynthonSpaceSearch/data/map_numbers.txt": {
745
+ "size": 541
746
+ },
747
+ "Code/GraphMol/SynthonSpaceSearch/data/missing_hit.txt": {
748
+ "size": 241
749
+ },
750
+ "Code/GraphMol/SynthonSpaceSearch/data/synthon_error.txt": {
751
+ "size": 100
752
+ },
753
+ "Code/GraphMol/SynthonSpaceSearch/data/triazole_space.txt": {
754
+ "size": 279
755
+ },
756
+ "Code/GraphMol/SynthonSpaceSearch/data/urea_3.txt": {
757
+ "size": 3278
758
+ },
759
+ "Code/GraphMol/SynthonSpaceSearch/data/urea_space.txt": {
760
+ "size": 397
761
+ },
762
+ "Code/GraphMol/TautomerQuery/CMakeLists.txt": {
763
+ "size": 545
764
+ },
765
+ "Code/GraphMol/TautomerQuery/Wrap/CMakeLists.txt": {
766
+ "size": 311
767
+ },
768
+ "Code/GraphMol/TautomerQuery/Wrap/rough_test.py": {
769
+ "size": 4568
770
+ },
771
+ "Code/GraphMol/Trajectory/CMakeLists.txt": {
772
+ "size": 422
773
+ },
774
+ "Code/GraphMol/UnitTestQueryMol.py": {
775
+ "size": 715
776
+ },
777
+ "Code/GraphMol/Wrap/CMakeLists.txt": {
778
+ "size": 3326
779
+ },
780
+ "Code/GraphMol/Wrap/Testing/Temporary/CTestCostData.txt": {
781
+ "size": 4
782
+ },
783
+ "Code/GraphMol/Wrap/rough_test.py": {
784
+ "size": 339626
785
+ },
786
+ "Code/GraphMol/Wrap/testConformer.py": {
787
+ "size": 3850
788
+ },
789
+ "Code/GraphMol/Wrap/testMultithreadedMolSupplier.py": {
790
+ "size": 6117
791
+ },
792
+ "Code/GraphMol/Wrap/testPropertyLists.py": {
793
+ "size": 5418
794
+ },
795
+ "Code/GraphMol/Wrap/testSCSR.py": {
796
+ "size": 4071
797
+ },
798
+ "Code/GraphMol/Wrap/testSGroups.py": {
799
+ "size": 18147
800
+ },
801
+ "Code/GraphMol/Wrap/testThreads.py": {
802
+ "size": 3347
803
+ },
804
+ "Code/GraphMol/Wrap/testTrajectory.py": {
805
+ "size": 19663
806
+ },
807
+ "Code/GraphMol/Wrap/test_cdxml.py": {
808
+ "size": 10619
809
+ },
810
+ "Code/GraphMol/Wrap/test_data/do_smiles.bomb.py": {
811
+ "size": 1111
812
+ },
813
+ "Code/GraphMol/Wrap/test_data/do_smiles.py": {
814
+ "size": 742
815
+ },
816
+ "Code/GraphMol/Wrap/test_data/easy_smiles.txt": {
817
+ "size": 299
818
+ },
819
+ "Code/GraphMol/Wrap/test_data/ntp_smiles.txt": {
820
+ "size": 15774
821
+ },
822
+ "Code/GraphMol/Wrap/test_data/rtecs_smiles.5000.txt": {
823
+ "size": 202650
824
+ },
825
+ "Code/GraphMol/Wrap/test_data/rtecs_smiles.txt": {
826
+ "size": 16414
827
+ },
828
+ "Code/GraphMol/regress.txt": {
829
+ "size": 52
830
+ },
831
+ "Code/JavaWrappers/CMakeLists.txt": {
832
+ "size": 1897
833
+ },
834
+ "Code/JavaWrappers/csharp_wrapper/CMakeLists.txt": {
835
+ "size": 4830
836
+ },
837
+ "Code/JavaWrappers/csharp_wrapper/RdkitTests/xunit.runner.json": {
838
+ "size": 70
839
+ },
840
+ "Code/JavaWrappers/gmwrapper/CMakeLists.txt": {
841
+ "size": 19618
842
+ },
843
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/AbbreviationsTests.java": {
844
+ "size": 2260
845
+ },
846
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/AlignTests.java": {
847
+ "size": 3049
848
+ },
849
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/AromaticTests.java": {
850
+ "size": 4749
851
+ },
852
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/AtomPairsTests.java": {
853
+ "size": 10793
854
+ },
855
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/AvalonLibTests.java": {
856
+ "size": 5640
857
+ },
858
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/BasicMolecule2Tests.java": {
859
+ "size": 6904
860
+ },
861
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/BasicMoleculeTests.java": {
862
+ "size": 9418
863
+ },
864
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/BitOpsTests.java": {
865
+ "size": 2658
866
+ },
867
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ChemAtomTests.java": {
868
+ "size": 4150
869
+ },
870
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ChemBondTests.java": {
871
+ "size": 3838
872
+ },
873
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ChemDrawTest.java": {
874
+ "size": 3755
875
+ },
876
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ChemReactionTests.java": {
877
+ "size": 20381
878
+ },
879
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ChemSmartsTests.java": {
880
+ "size": 3292
881
+ },
882
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ChemTests.java": {
883
+ "size": 3234
884
+ },
885
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ChemTransformsTests.java": {
886
+ "size": 2954
887
+ },
888
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/Chemv2Tests.java": {
889
+ "size": 33999
890
+ },
891
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ConformerTests.java": {
892
+ "size": 5051
893
+ },
894
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/DescriptorTests.java": {
895
+ "size": 9960
896
+ },
897
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/DistanceGeometryTests.java": {
898
+ "size": 18906
899
+ },
900
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/DiversityPickerTests.java": {
901
+ "size": 4456
902
+ },
903
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ErrorHandlingTests.java": {
904
+ "size": 5131
905
+ },
906
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/FMCSTests.java": {
907
+ "size": 5275
908
+ },
909
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/FilterCatalogTests.java": {
910
+ "size": 7411
911
+ },
912
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/FingerprintsTests.java": {
913
+ "size": 7023
914
+ },
915
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ForceFieldsTests.java": {
916
+ "size": 34702
917
+ },
918
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/GraphMolTest.java": {
919
+ "size": 2737
920
+ },
921
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/GraphMolTestSuite.java": {
922
+ "size": 2567
923
+ },
924
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/GzStreamTests.java": {
925
+ "size": 930
926
+ },
927
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/HManipulationsTests.java": {
928
+ "size": 3229
929
+ },
930
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/InchiTests.java": {
931
+ "size": 2366
932
+ },
933
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/LipinskiTests.java": {
934
+ "size": 5241
935
+ },
936
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/MemoryTests.java": {
937
+ "size": 4662
938
+ },
939
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/MolDraw2DCairoTests.java": {
940
+ "size": 1081
941
+ },
942
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/MolEnumeratorTests.java": {
943
+ "size": 4058
944
+ },
945
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/MolHashTest.java": {
946
+ "size": 778
947
+ },
948
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/MolQueryTests.java": {
949
+ "size": 3410
950
+ },
951
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/MolStandardizeTest.java": {
952
+ "size": 2271
953
+ },
954
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/PDBTests.java": {
955
+ "size": 3140
956
+ },
957
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/PicklingTests.java": {
958
+ "size": 6951
959
+ },
960
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/QueryAtomTest.java": {
961
+ "size": 10424
962
+ },
963
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/RGroupDecompositionTests.java": {
964
+ "size": 1376
965
+ },
966
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/RascalMCESTest.java": {
967
+ "size": 2174
968
+ },
969
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/ScaffoldNetworkTests.java": {
970
+ "size": 1439
971
+ },
972
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/SequenceTests.java": {
973
+ "size": 3335
974
+ },
975
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/SmilesCreationTests.java": {
976
+ "size": 5612
977
+ },
978
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/SmilesDetailsTests.java": {
979
+ "size": 37762
980
+ },
981
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/SmilesTests.java": {
982
+ "size": 7587
983
+ },
984
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/SubstanceGroupTests.java": {
985
+ "size": 3815
986
+ },
987
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/SubstructLibraryTests.java": {
988
+ "size": 14417
989
+ },
990
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/SuppliersTests.java": {
991
+ "size": 5269
992
+ },
993
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/TautomerQueryTests.java": {
994
+ "size": 2099
995
+ },
996
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/TrajectoryTests.java": {
997
+ "size": 28071
998
+ },
999
+ "Code/JavaWrappers/gmwrapper/src-test/org/RDKit/WrapperTests.java": {
1000
+ "size": 12435
1001
+ },
1002
+ "Code/JavaWrappers/make_templates.py": {
1003
+ "size": 1327
1004
+ },
1005
+ "Code/JavaWrappers/parse_doxy_html.py": {
1006
+ "size": 14751
1007
+ },
1008
+ "Code/ML/CMakeLists.txt": {
1009
+ "size": 213
1010
+ },
1011
+ "Code/ML/Cluster/CMakeLists.txt": {
1012
+ "size": 26
1013
+ },
1014
+ "Code/ML/Cluster/Murtagh/CMakeLists.txt": {
1015
+ "size": 327
1016
+ },
1017
+ "Code/ML/Data/CMakeLists.txt": {
1018
+ "size": 143
1019
+ },
1020
+ "Code/ML/InfoTheory/CMakeLists.txt": {
1021
+ "size": 214
1022
+ },
1023
+ "Code/ML/InfoTheory/Wrap/CMakeLists.txt": {
1024
+ "size": 368
1025
+ },
1026
+ "Code/ML/InfoTheory/Wrap/testRanker.py": {
1027
+ "size": 4382
1028
+ },
1029
+ "Code/MinimalLib/CMakeLists.txt": {
1030
+ "size": 4556
1031
+ },
1032
+ "Code/MinimalLib/README.md": {
1033
+ "size": 5579
1034
+ },
1035
+ "Code/MinimalLib/docker/docker_compose_build_minimallib.yml": {
1036
+ "size": 2056
1037
+ },
1038
+ "Code/MinimalLib/simple.py": {
1039
+ "size": 455
1040
+ },
1041
+ "Code/MinimalLib/tests/tests.js": {
1042
+ "size": 171081
1043
+ },
1044
+ "Code/Numerics/Alignment/CMakeLists.txt": {
1045
+ "size": 332
1046
+ },
1047
+ "Code/Numerics/Alignment/Wrap/CMakeLists.txt": {
1048
+ "size": 276
1049
+ },
1050
+ "Code/Numerics/Alignment/Wrap/testAlignment.py": {
1051
+ "size": 5719
1052
+ },
1053
+ "Code/Numerics/CMakeLists.txt": {
1054
+ "size": 379
1055
+ },
1056
+ "Code/Numerics/EigenSolvers/CMakeLists.txt": {
1057
+ "size": 443
1058
+ },
1059
+ "Code/Numerics/Optimizer/CMakeLists.txt": {
1060
+ "size": 331
1061
+ },
1062
+ "Code/PgSQL/rdkit/CMakeLists.txt": {
1063
+ "size": 12222
1064
+ },
1065
+ "Code/PgSQL/rdkit/README.md": {
1066
+ "size": 19464
1067
+ },
1068
+ "Code/Query/CMakeLists.txt": {
1069
+ "size": 436
1070
+ },
1071
+ "Code/RDBoost/CMakeLists.txt": {
1072
+ "size": 1577
1073
+ },
1074
+ "Code/RDBoost/Wrap/CMakeLists.txt": {
1075
+ "size": 187
1076
+ },
1077
+ "Code/RDGeneral/CMakeLists.txt": {
1078
+ "size": 2435
1079
+ },
1080
+ "Code/RDStreams/CMakeLists.txt": {
1081
+ "size": 147
1082
+ },
1083
+ "Code/SimDivPickers/CMakeLists.txt": {
1084
+ "size": 609
1085
+ },
1086
+ "Code/SimDivPickers/Wrap/CMakeLists.txt": {
1087
+ "size": 403
1088
+ },
1089
+ "Code/SimDivPickers/Wrap/testMaxMin.py": {
1090
+ "size": 756
1091
+ },
1092
+ "Code/SimDivPickers/Wrap/testPickers.py": {
1093
+ "size": 12016
1094
+ },
1095
+ "Code/cmake/Modules/fixup_coverage.py": {
1096
+ "size": 974
1097
+ },
1098
+ "Code/notes.txt": {
1099
+ "size": 1590
1100
+ },
1101
+ "Contrib/AtomAtomSimilarity/AtomAtomPathSimilarity.py": {
1102
+ "size": 14150
1103
+ },
1104
+ "Contrib/CMakeLists.txt": {
1105
+ "size": 37
1106
+ },
1107
+ "Contrib/CalcLigRMSD/CalcLigRMSD.py": {
1108
+ "size": 3355
1109
+ },
1110
+ "Contrib/CalcLigRMSD/README.md": {
1111
+ "size": 3964
1112
+ },
1113
+ "Contrib/ChiralPairs/ChiralDescriptors.py": {
1114
+ "size": 16038
1115
+ },
1116
+ "Contrib/ChiralPairs/README.txt": {
1117
+ "size": 537
1118
+ },
1119
+ "Contrib/ConformerParser/CMakeLists.txt": {
1120
+ "size": 378
1121
+ },
1122
+ "Contrib/ConformerParser/Wrap/CMakeLists.txt": {
1123
+ "size": 333
1124
+ },
1125
+ "Contrib/ConformerParser/Wrap/testConformerParser.py": {
1126
+ "size": 1238
1127
+ },
1128
+ "Contrib/Fastcluster/README.md": {
1129
+ "size": 1533
1130
+ },
1131
+ "Contrib/Fastcluster/fastcluster.py": {
1132
+ "size": 2323
1133
+ },
1134
+ "Contrib/Fastcluster/testdata/sdf2smi.py": {
1135
+ "size": 358
1136
+ },
1137
+ "Contrib/FreeWilson/README.md": {
1138
+ "size": 4543
1139
+ },
1140
+ "Contrib/FreeWilson/freewilson.py": {
1141
+ "size": 23050
1142
+ },
1143
+ "Contrib/FreeWilson/pytest.ini": {
1144
+ "size": 37
1145
+ },
1146
+ "Contrib/FreeWilson/requirements.txt": {
1147
+ "size": 18
1148
+ },
1149
+ "Contrib/FreeWilson/setup.py": {
1150
+ "size": 350
1151
+ },
1152
+ "Contrib/FreeWilson/test/test_freewilson.py": {
1153
+ "size": 2200
1154
+ },
1155
+ "Contrib/Glare/README.txt": {
1156
+ "size": 1812
1157
+ },
1158
+ "Contrib/Glare/glare.py": {
1159
+ "size": 16258
1160
+ },
1161
+ "Contrib/IFG/ifg.py": {
1162
+ "size": 3995
1163
+ },
1164
+ "Contrib/LEF/AddLabels.py": {
1165
+ "size": 3089
1166
+ },
1167
+ "Contrib/LEF/ClusterFps.py": {
1168
+ "size": 2765
1169
+ },
1170
+ "Contrib/LEF/CreateFps.py": {
1171
+ "size": 4557
1172
+ },
1173
+ "Contrib/LEF/DistancePlot.py": {
1174
+ "size": 3988
1175
+ },
1176
+ "Contrib/LEF/DistancePredict.py": {
1177
+ "size": 7209
1178
+ },
1179
+ "Contrib/LEF/README.txt": {
1180
+ "size": 2311
1181
+ },
1182
+ "Contrib/M_Kossner/Frames.py": {
1183
+ "size": 6450
1184
+ },
1185
+ "Contrib/MolVS/molvs_cli.py": {
1186
+ "size": 3650
1187
+ },
1188
+ "Contrib/NIBRSubstructureFilters/README.md": {
1189
+ "size": 6535
1190
+ },
1191
+ "Contrib/NIBRSubstructureFilters/assignSubstructureFilters.py": {
1192
+ "size": 4755
1193
+ },
1194
+ "Contrib/NP_Score/npscorer.py": {
1195
+ "size": 4547
1196
+ },
1197
+ "Contrib/PBF/pbf.py": {
1198
+ "size": 1746
1199
+ },
1200
+ "Contrib/RxnRoleAssignment/README.txt": {
1201
+ "size": 485
1202
+ },
1203
+ "Contrib/RxnRoleAssignment/__init__.py": {
1204
+ "size": 0
1205
+ },
1206
+ "Contrib/RxnRoleAssignment/identifyReactants.py": {
1207
+ "size": 19215
1208
+ },
1209
+ "Contrib/RxnRoleAssignment/utils.py": {
1210
+ "size": 2973
1211
+ },
1212
+ "Contrib/SA_Score/UnitTestSAScore.py": {
1213
+ "size": 937
1214
+ },
1215
+ "Contrib/SA_Score/build_sascore_db.py": {
1216
+ "size": 9080
1217
+ },
1218
+ "Contrib/SA_Score/data/zim.100.txt": {
1219
+ "size": 5949
1220
+ },
1221
+ "Contrib/SA_Score/sascorer.py": {
1222
+ "size": 5913
1223
+ },
1224
+ "Contrib/efgs/README.md": {
1225
+ "size": 972
1226
+ },
1227
+ "Contrib/efgs/efgs.py": {
1228
+ "size": 26346
1229
+ },
1230
+ "Contrib/efgs/try_efgs.py": {
1231
+ "size": 8683
1232
+ },
1233
+ "Contrib/fraggle/atomcontrib.py": {
1234
+ "size": 5037
1235
+ },
1236
+ "Contrib/fraggle/cxn_tversky.py": {
1237
+ "size": 4137
1238
+ },
1239
+ "Contrib/fraggle/fraggle.py": {
1240
+ "size": 2651
1241
+ },
1242
+ "Contrib/fraggle/rdkit_tversky.py": {
1243
+ "size": 3869
1244
+ },
1245
+ "Contrib/fraggle/readme.txt": {
1246
+ "size": 5004
1247
+ },
1248
+ "Contrib/mmpa/README.txt": {
1249
+ "size": 13855
1250
+ },
1251
+ "Contrib/mmpa/cansmirk.py": {
1252
+ "size": 2891
1253
+ },
1254
+ "Contrib/mmpa/create_mmp_db.py": {
1255
+ "size": 10136
1256
+ },
1257
+ "Contrib/mmpa/data/sample_cansmirks.txt": {
1258
+ "size": 135
1259
+ },
1260
+ "Contrib/mmpa/data/sample_db_input_smi.txt": {
1261
+ "size": 34
1262
+ },
1263
+ "Contrib/mmpa/data/sample_db_input_subs.txt": {
1264
+ "size": 12
1265
+ },
1266
+ "Contrib/mmpa/data/sample_db_input_subs_smarts.txt": {
1267
+ "size": 15
1268
+ },
1269
+ "Contrib/mmpa/data/sample_db_input_trans.txt": {
1270
+ "size": 32
1271
+ },
1272
+ "Contrib/mmpa/data/sample_db_input_trans_smarts.txt": {
1273
+ "size": 8
1274
+ },
1275
+ "Contrib/mmpa/data/sample_db_search_smi_output.txt": {
1276
+ "size": 103
1277
+ },
1278
+ "Contrib/mmpa/data/sample_db_search_subs_output.txt": {
1279
+ "size": 130
1280
+ },
1281
+ "Contrib/mmpa/data/sample_db_search_subs_smart_output.txt": {
1282
+ "size": 1540
1283
+ },
1284
+ "Contrib/mmpa/data/sample_db_search_trans_output.txt": {
1285
+ "size": 121
1286
+ },
1287
+ "Contrib/mmpa/data/sample_db_search_trans_smarts_output.txt": {
1288
+ "size": 126
1289
+ },
1290
+ "Contrib/mmpa/data/sample_fragmented.txt": {
1291
+ "size": 7101
1292
+ },
1293
+ "Contrib/mmpa/data/sample_mol_trans_output.txt": {
1294
+ "size": 157
1295
+ },
1296
+ "Contrib/mmpa/data/sample_smirks.txt": {
1297
+ "size": 138
1298
+ },
1299
+ "Contrib/mmpa/data/sample_smirks_mol_trans.txt": {
1300
+ "size": 25
1301
+ },
1302
+ "Contrib/mmpa/data/sample_transfroms.txt": {
1303
+ "size": 84
1304
+ },
1305
+ "Contrib/mmpa/indexing.py": {
1306
+ "size": 18927
1307
+ },
1308
+ "Contrib/mmpa/mol_transform.py": {
1309
+ "size": 4352
1310
+ },
1311
+ "Contrib/mmpa/rfrag.py": {
1312
+ "size": 8062
1313
+ },
1314
+ "Contrib/mmpa/search_mmp_db.py": {
1315
+ "size": 16269
1316
+ },
1317
+ "Contrib/mmpa/test_rfrag.py": {
1318
+ "size": 624
1319
+ },
1320
+ "Contrib/pzc/p_con.py": {
1321
+ "size": 45655
1322
+ },
1323
+ "Contrib/pzc/readme.md": {
1324
+ "size": 1484
1325
+ },
1326
+ "Data/Crippen.txt": {
1327
+ "size": 4205
1328
+ },
1329
+ "Data/DTDs/validate.py": {
1330
+ "size": 127
1331
+ },
1332
+ "Data/Fonts/amadeus_font_license.txt": {
1333
+ "size": 847
1334
+ },
1335
+ "Data/Fonts/font_dumper.py": {
1336
+ "size": 1286
1337
+ },
1338
+ "Data/Fonts/roboto_regular_license.txt": {
1339
+ "size": 149
1340
+ },
1341
+ "Data/Fonts/telex_font_license.txt": {
1342
+ "size": 4401
1343
+ },
1344
+ "Data/FunctionalGroups.txt": {
1345
+ "size": 2466
1346
+ },
1347
+ "Data/Functional_Group_Hierarchy.txt": {
1348
+ "size": 5990
1349
+ },
1350
+ "Data/Pains/README.md": {
1351
+ "size": 738
1352
+ },
1353
+ "Data/Pains/test_data/run_tests.py": {
1354
+ "size": 1231
1355
+ },
1356
+ "Data/Pains/test_data/test_set3.txt": {
1357
+ "size": 79805
1358
+ },
1359
+ "Data/Salts.txt": {
1360
+ "size": 2702
1361
+ },
1362
+ "Data/SmartsLib/RLewis_smarts.txt": {
1363
+ "size": 14235
1364
+ },
1365
+ "Data/SmartsLib/patty_rules.txt": {
1366
+ "size": 9269
1367
+ },
1368
+ "Data/SmartsLib/tests/bench2.py": {
1369
+ "size": 1267
1370
+ },
1371
+ "Docs/Book/BackwardsIncompatibleChanges.md": {
1372
+ "size": 13000
1373
+ },
1374
+ "Docs/Book/C++Examples/CMakeLists.txt": {
1375
+ "size": 1642
1376
+ },
1377
+ "Docs/Book/Cartridge.md": {
1378
+ "size": 46424
1379
+ },
1380
+ "Docs/Book/GettingStartedInC++.md": {
1381
+ "size": 58999
1382
+ },
1383
+ "Docs/Book/GettingStartedWithContributing.md": {
1384
+ "size": 32861
1385
+ },
1386
+ "Docs/Book/Install.md": {
1387
+ "size": 22788
1388
+ },
1389
+ "Docs/Book/Overview.md": {
1390
+ "size": 7189
1391
+ },
1392
+ "Docs/Book/conf.py": {
1393
+ "size": 7545
1394
+ },
1395
+ "Docs/Book/data/README.md": {
1396
+ "size": 891
1397
+ },
1398
+ "Docs/Book/data/s1p_chembldoc89753.txt": {
1399
+ "size": 4382
1400
+ },
1401
+ "Docs/Book/data/test_multi_colours.py": {
1402
+ "size": 1843
1403
+ },
1404
+ "Docs/Book/exts/extapi.py": {
1405
+ "size": 2665
1406
+ },
1407
+ "Docs/Book_jp/conf.py": {
1408
+ "size": 7036
1409
+ },
1410
+ "Docs/Code/CIPLabeling.md": {
1411
+ "size": 2374
1412
+ },
1413
+ "Docs/Code/EnhancedStereo.md": {
1414
+ "size": 2898
1415
+ },
1416
+ "Docs/Code/SGroups.md": {
1417
+ "size": 3680
1418
+ },
1419
+ "Docs/Code/gsocGeneralFileReader.md": {
1420
+ "size": 6431
1421
+ },
1422
+ "Docs/Notebooks/compounds.txt": {
1423
+ "size": 524313
1424
+ },
1425
+ "External/AvalonTools/CMakeLists.txt": {
1426
+ "size": 3590
1427
+ },
1428
+ "External/AvalonTools/Wrap/CMakeLists.txt": {
1429
+ "size": 324
1430
+ },
1431
+ "External/AvalonTools/Wrap/testAvalonTools.py": {
1432
+ "size": 14082
1433
+ },
1434
+ "External/CMakeLists.txt": {
1435
+ "size": 333
1436
+ },
1437
+ "External/ChemDraw/CMakeLists.txt": {
1438
+ "size": 8207
1439
+ },
1440
+ "External/ChemDraw/Wrap/CMakeLists.txt": {
1441
+ "size": 257
1442
+ },
1443
+ "External/ChemDraw/Wrap/testChemDraw.py": {
1444
+ "size": 6868
1445
+ },
1446
+ "External/CoordGen/CMakeLists.txt": {
1447
+ "size": 4358
1448
+ },
1449
+ "External/CoordGen/Wrap/CMakeLists.txt": {
1450
+ "size": 329
1451
+ },
1452
+ "External/CoordGen/Wrap/testCoordGen.py": {
1453
+ "size": 2961
1454
+ },
1455
+ "External/Eigen/CMakeLists.txt": {
1456
+ "size": 531
1457
+ },
1458
+ "External/FreeSASA/CMakeLists.txt": {
1459
+ "size": 6501
1460
+ },
1461
+ "External/FreeSASA/Wrap/CMakeLists.txt": {
1462
+ "size": 312
1463
+ },
1464
+ "External/FreeSASA/Wrap/testFreeSASA.py": {
1465
+ "size": 21687
1466
+ },
1467
+ "External/GA/CMakeLists.txt": {
1468
+ "size": 184
1469
+ },
1470
+ "External/INCHI-API/CMakeLists.txt": {
1471
+ "size": 4656
1472
+ },
1473
+ "External/INCHI-API/Wrap/CMakeLists.txt": {
1474
+ "size": 160
1475
+ },
1476
+ "External/INCHI-API/python/inchi.py": {
1477
+ "size": 8662
1478
+ },
1479
+ "External/INCHI-API/python/noinchi.py": {
1480
+ "size": 1679
1481
+ },
1482
+ "External/RingFamilies/CMakeLists.txt": {
1483
+ "size": 2339
1484
+ },
1485
+ "External/YAeHMOP/CMakeLists.txt": {
1486
+ "size": 2032
1487
+ },
1488
+ "External/YAeHMOP/Wrap/CMakeLists.txt": {
1489
+ "size": 276
1490
+ },
1491
+ "External/YAeHMOP/Wrap/testEHTTools.py": {
1492
+ "size": 3562
1493
+ },
1494
+ "External/pubchem_shape/CMakeLists.txt": {
1495
+ "size": 2398
1496
+ },
1497
+ "External/pubchem_shape/README.md": {
1498
+ "size": 190
1499
+ },
1500
+ "External/pubchem_shape/Wrap/CMakeLists.txt": {
1501
+ "size": 528
1502
+ },
1503
+ "External/pubchem_shape/Wrap/test_rdshapealign.py": {
1504
+ "size": 5302
1505
+ },
1506
+ "External/pymol/modules/pymol/rpc.py": {
1507
+ "size": 17575
1508
+ },
1509
+ "Projects/CMakeLists.txt": {
1510
+ "size": 67
1511
+ },
1512
+ "Projects/DbCLI/CreateDb.py": {
1513
+ "size": 20886
1514
+ },
1515
+ "Projects/DbCLI/SearchDb.py": {
1516
+ "size": 25224
1517
+ },
1518
+ "Projects/DbCLI/UnitTestDbCLI.py": {
1519
+ "size": 21219
1520
+ },
1521
+ "Projects/pytest.ini": {
1522
+ "size": 150
1523
+ },
1524
+ "README.md": {
1525
+ "size": 3801
1526
+ },
1527
+ "Regress/Data/RLewis_smarts.txt": {
1528
+ "size": 14289
1529
+ },
1530
+ "Regress/Scripts/chiral_embed.py": {
1531
+ "size": 1332
1532
+ },
1533
+ "Regress/Scripts/fingerprint_screenout.py": {
1534
+ "size": 3956
1535
+ },
1536
+ "Regress/Scripts/new_timings.py": {
1537
+ "size": 4844
1538
+ },
1539
+ "Regress/Scripts/timings.py": {
1540
+ "size": 6197
1541
+ },
1542
+ "ReleaseNotes.md": {
1543
+ "size": 434983
1544
+ },
1545
+ "Scripts/FeatFinderCLI.py": {
1546
+ "size": 309
1547
+ },
1548
+ "Scripts/PythonFormat.py": {
1549
+ "size": 2154
1550
+ },
1551
+ "Scripts/README.md": {
1552
+ "size": 314
1553
+ },
1554
+ "Scripts/gen_rdkit_stubs/__init__.py": {
1555
+ "size": 22995
1556
+ },
1557
+ "Scripts/gen_rdkit_stubs/__main__.py": {
1558
+ "size": 2506
1559
+ },
1560
+ "Scripts/gen_rdkit_stubs/worker.py": {
1561
+ "size": 3026
1562
+ },
1563
+ "Scripts/patch_rdkit_docstrings/__init__.py": {
1564
+ "size": 75632
1565
+ },
1566
+ "Scripts/patch_rdkit_docstrings/__main__.py": {
1567
+ "size": 3261
1568
+ },
1569
+ "Scripts/patch_rdkit_docstrings/clang_worker.py": {
1570
+ "size": 1372
1571
+ },
1572
+ "Scripts/run_python_tests.py": {
1573
+ "size": 645
1574
+ },
1575
+ "Web/RDExtras/MolDepict.py": {
1576
+ "size": 1697
1577
+ },
1578
+ "Web/RDExtras/MolImage.py": {
1579
+ "size": 1947
1580
+ },
1581
+ "azure-pipelines.yml": {
1582
+ "size": 3578
1583
+ },
1584
+ "build_support/pkg_version.py": {
1585
+ "size": 2450
1586
+ },
1587
+ "license.txt": {
1588
+ "size": 1580
1589
+ },
1590
+ "rdkit-stubs/CMakeLists.txt": {
1591
+ "size": 1908
1592
+ },
1593
+ "rdkit/Avalon/__init__.py": {
1594
+ "size": 0
1595
+ },
1596
+ "rdkit/CMakeLists.txt": {
1597
+ "size": 890
1598
+ },
1599
+ "rdkit/Chem/AllChem.py": {
1600
+ "size": 17005
1601
+ },
1602
+ "rdkit/Chem/AtomPairs/Pairs.py": {
1603
+ "size": 5702
1604
+ },
1605
+ "rdkit/Chem/AtomPairs/Sheridan.py": {
1606
+ "size": 3721
1607
+ },
1608
+ "rdkit/Chem/AtomPairs/Torsions.py": {
1609
+ "size": 5446
1610
+ },
1611
+ "rdkit/Chem/AtomPairs/UnitTestDescriptors.py": {
1612
+ "size": 4438
1613
+ },
1614
+ "rdkit/Chem/AtomPairs/Utils.py": {
1615
+ "size": 7565
1616
+ },
1617
+ "rdkit/Chem/AtomPairs/__init__.py": {
1618
+ "size": 0
1619
+ },
1620
+ "rdkit/Chem/BRICS.py": {
1621
+ "size": 33343
1622
+ },
1623
+ "rdkit/Chem/BuildFragmentCatalog.py": {
1624
+ "size": 19000
1625
+ },
1626
+ "rdkit/Chem/CMakeLists.txt": {
1627
+ "size": 81
1628
+ },
1629
+ "rdkit/Chem/ChemUtils/AlignDepict.py": {
1630
+ "size": 2923
1631
+ },
1632
+ "rdkit/Chem/ChemUtils/BulkTester.py": {
1633
+ "size": 1974
1634
+ },
1635
+ "rdkit/Chem/ChemUtils/DescriptorUtilities.py": {
1636
+ "size": 1798
1637
+ },
1638
+ "rdkit/Chem/ChemUtils/SDFToCSV.py": {
1639
+ "size": 2507
1640
+ },
1641
+ "rdkit/Chem/ChemUtils/TemplateExpand.py": {
1642
+ "size": 14333
1643
+ },
1644
+ "rdkit/Chem/ChemUtils/UnitTestAlignDepict.py": {
1645
+ "size": 1724
1646
+ },
1647
+ "rdkit/Chem/ChemUtils/UnitTestSDFToCSV.py": {
1648
+ "size": 2546
1649
+ },
1650
+ "rdkit/Chem/ChemUtils/__init__.py": {
1651
+ "size": 0
1652
+ },
1653
+ "rdkit/Chem/ChemicalFeatures.py": {
1654
+ "size": 719
1655
+ },
1656
+ "rdkit/Chem/ChemicalForceFields.py": {
1657
+ "size": 363
1658
+ },
1659
+ "rdkit/Chem/Crippen.py": {
1660
+ "size": 6097
1661
+ },
1662
+ "rdkit/Chem/DSViewer.py": {
1663
+ "size": 12132
1664
+ },
1665
+ "rdkit/Chem/Descriptors.py": {
1666
+ "size": 9068
1667
+ },
1668
+ "rdkit/Chem/Descriptors3D.py": {
1669
+ "size": 7194
1670
+ },
1671
+ "rdkit/Chem/Draw/IPythonConsole.py": {
1672
+ "size": 17158
1673
+ },
1674
+ "rdkit/Chem/Draw/InteractiveRenderer.py": {
1675
+ "size": 14216
1676
+ },
1677
+ "rdkit/Chem/Draw/MolDrawing.py": {
1678
+ "size": 21996
1679
+ },
1680
+ "rdkit/Chem/Draw/SimilarityMaps.py": {
1681
+ "size": 16646
1682
+ },
1683
+ "rdkit/Chem/Draw/UnitTestDraw.py": {
1684
+ "size": 18902
1685
+ },
1686
+ "rdkit/Chem/Draw/UnitTestIPython.py": {
1687
+ "size": 4503
1688
+ },
1689
+ "rdkit/Chem/Draw/UnitTestSimilarityMaps.py": {
1690
+ "size": 8999
1691
+ },
1692
+ "rdkit/Chem/Draw/__init__.py": {
1693
+ "size": 36229
1694
+ },
1695
+ "rdkit/Chem/EState/AtomTypes.py": {
1696
+ "size": 4036
1697
+ },
1698
+ "rdkit/Chem/EState/EState.py": {
1699
+ "size": 2507
1700
+ },
1701
+ "rdkit/Chem/EState/EState_VSA.py": {
1702
+ "size": 3567
1703
+ },
1704
+ "rdkit/Chem/EState/Fingerprinter.py": {
1705
+ "size": 2124
1706
+ },
1707
+ "rdkit/Chem/EState/UnitTestEState.py": {
1708
+ "size": 5008
1709
+ },
1710
+ "rdkit/Chem/EState/UnitTestFingerprints.py": {
1711
+ "size": 1859
1712
+ },
1713
+ "rdkit/Chem/EState/UnitTestTypes.py": {
1714
+ "size": 2037
1715
+ },
1716
+ "rdkit/Chem/EState/UnitTestVSA.py": {
1717
+ "size": 1528
1718
+ },
1719
+ "rdkit/Chem/EState/__init__.py": {
1720
+ "size": 386
1721
+ },
1722
+ "rdkit/Chem/EnumerateHeterocycles.py": {
1723
+ "size": 13108
1724
+ },
1725
+ "rdkit/Chem/EnumerateStereoisomers.py": {
1726
+ "size": 14589
1727
+ },
1728
+ "rdkit/Chem/FastSDMolSupplier.py": {
1729
+ "size": 499
1730
+ },
1731
+ "rdkit/Chem/FeatFinderCLI.py": {
1732
+ "size": 3310
1733
+ },
1734
+ "rdkit/Chem/FeatMaps/FeatMapParser.py": {
1735
+ "size": 5071
1736
+ },
1737
+ "rdkit/Chem/FeatMaps/FeatMapPoint.py": {
1738
+ "size": 3283
1739
+ },
1740
+ "rdkit/Chem/FeatMaps/FeatMapUtils.py": {
1741
+ "size": 7335
1742
+ },
1743
+ "rdkit/Chem/FeatMaps/FeatMaps.py": {
1744
+ "size": 7487
1745
+ },
1746
+ "rdkit/Chem/FeatMaps/UnitTestFeatMap.py": {
1747
+ "size": 11596
1748
+ },
1749
+ "rdkit/Chem/FeatMaps/UnitTestFeatMapParser.py": {
1750
+ "size": 4293
1751
+ },
1752
+ "rdkit/Chem/FeatMaps/UnitTestFeatMapPoint.py": {
1753
+ "size": 592
1754
+ },
1755
+ "rdkit/Chem/FeatMaps/UnitTestFeatMapUtils.py": {
1756
+ "size": 10562
1757
+ },
1758
+ "rdkit/Chem/FeatMaps/__init__.py": {
1759
+ "size": 0
1760
+ },
1761
+ "rdkit/Chem/Features/FeatDirUtilsRD.py": {
1762
+ "size": 11964
1763
+ },
1764
+ "rdkit/Chem/Features/ShowFeats.py": {
1765
+ "size": 11632
1766
+ },
1767
+ "rdkit/Chem/Features/UnitTestFeatDirUtilsRD.py": {
1768
+ "size": 7057
1769
+ },
1770
+ "rdkit/Chem/Features/__init__.py": {
1771
+ "size": 0
1772
+ },
1773
+ "rdkit/Chem/FilterCatalog.py": {
1774
+ "size": 2188
1775
+ },
1776
+ "rdkit/Chem/Fingerprints/ClusterMols.py": {
1777
+ "size": 5697
1778
+ },
1779
+ "rdkit/Chem/Fingerprints/DbFpSupplier.py": {
1780
+ "size": 4315
1781
+ },
1782
+ "rdkit/Chem/Fingerprints/FingerprintMols.py": {
1783
+ "size": 16446
1784
+ },
1785
+ "rdkit/Chem/Fingerprints/MolSimilarity.py": {
1786
+ "size": 9568
1787
+ },
1788
+ "rdkit/Chem/Fingerprints/SimilarityScreener.py": {
1789
+ "size": 4687
1790
+ },
1791
+ "rdkit/Chem/Fingerprints/UnitTestDbFpSupplier.py": {
1792
+ "size": 1058
1793
+ },
1794
+ "rdkit/Chem/Fingerprints/UnitTestFingerprints.py": {
1795
+ "size": 2926
1796
+ },
1797
+ "rdkit/Chem/Fingerprints/UnitTestSimScreener.py": {
1798
+ "size": 4160
1799
+ },
1800
+ "rdkit/Chem/Fingerprints/__init__.py": {
1801
+ "size": 67
1802
+ },
1803
+ "rdkit/Chem/Fraggle/FraggleSim.py": {
1804
+ "size": 14344
1805
+ },
1806
+ "rdkit/Chem/Fraggle/UnitTestFraggle.py": {
1807
+ "size": 7484
1808
+ },
1809
+ "rdkit/Chem/Fraggle/__init__.py": {
1810
+ "size": 0
1811
+ },
1812
+ "rdkit/Chem/FragmentCatalog.py": {
1813
+ "size": 2420
1814
+ },
1815
+ "rdkit/Chem/FragmentMatcher.py": {
1816
+ "size": 2276
1817
+ },
1818
+ "rdkit/Chem/Fragments.py": {
1819
+ "size": 1618
1820
+ },
1821
+ "rdkit/Chem/FunctionalGroups.py": {
1822
+ "size": 5027
1823
+ },
1824
+ "rdkit/Chem/GraphDescriptors.py": {
1825
+ "size": 20596
1826
+ },
1827
+ "rdkit/Chem/Graphs.py": {
1828
+ "size": 1289
1829
+ },
1830
+ "rdkit/Chem/Lipinski.py": {
1831
+ "size": 4359
1832
+ },
1833
+ "rdkit/Chem/MACCSkeys.py": {
1834
+ "size": 11744
1835
+ },
1836
+ "rdkit/Chem/MCS.py": {
1837
+ "size": 17304
1838
+ },
1839
+ "rdkit/Chem/MolCatalog.py": {
1840
+ "size": 84
1841
+ },
1842
+ "rdkit/Chem/MolDb/FingerprintUtils.py": {
1843
+ "size": 3434
1844
+ },
1845
+ "rdkit/Chem/MolDb/Loader.py": {
1846
+ "size": 408
1847
+ },
1848
+ "rdkit/Chem/MolDb/Loader_orig.py": {
1849
+ "size": 6570
1850
+ },
1851
+ "rdkit/Chem/MolDb/Loader_sa.py": {
1852
+ "size": 5957
1853
+ },
1854
+ "rdkit/Chem/MolDb/__init__.py": {
1855
+ "size": 0
1856
+ },
1857
+ "rdkit/Chem/MolKey/InchiInfo.py": {
1858
+ "size": 7077
1859
+ },
1860
+ "rdkit/Chem/MolKey/MolKey.py": {
1861
+ "size": 15051
1862
+ },
1863
+ "rdkit/Chem/MolKey/UnitTestMolKey.py": {
1864
+ "size": 5264
1865
+ },
1866
+ "rdkit/Chem/MolKey/__init__.py": {
1867
+ "size": 0
1868
+ },
1869
+ "rdkit/Chem/MolStandardize/UnitTestMolStandardize.py": {
1870
+ "size": 874
1871
+ },
1872
+ "rdkit/Chem/MolStandardize/__init__.py": {
1873
+ "size": 908
1874
+ },
1875
+ "rdkit/Chem/MolSurf.py": {
1876
+ "size": 14630
1877
+ },
1878
+ "rdkit/Chem/PandasPatcher.py": {
1879
+ "size": 10127
1880
+ },
1881
+ "rdkit/Chem/PandasTools.py": {
1882
+ "size": 27100
1883
+ },
1884
+ "rdkit/Chem/Pharm2D/Generate.py": {
1885
+ "size": 4979
1886
+ },
1887
+ "rdkit/Chem/Pharm2D/Gobbi_Pharm2D.py": {
1888
+ "size": 1901
1889
+ },
1890
+ "rdkit/Chem/Pharm2D/LazyGenerator.py": {
1891
+ "size": 4262
1892
+ },
1893
+ "rdkit/Chem/Pharm2D/Matcher.py": {
1894
+ "size": 4028
1895
+ },
1896
+ "rdkit/Chem/Pharm2D/SigFactory.py": {
1897
+ "size": 10231
1898
+ },
1899
+ "rdkit/Chem/Pharm2D/UnitTestGenerate.py": {
1900
+ "size": 430
1901
+ },
1902
+ "rdkit/Chem/Pharm2D/UnitTestGobbi.py": {
1903
+ "size": 5454
1904
+ },
1905
+ "rdkit/Chem/Pharm2D/UnitTestLazyGenerator.py": {
1906
+ "size": 2437
1907
+ },
1908
+ "rdkit/Chem/Pharm2D/UnitTestMatcher.py": {
1909
+ "size": 3048
1910
+ },
1911
+ "rdkit/Chem/Pharm2D/UnitTestSignature.py": {
1912
+ "size": 8547
1913
+ },
1914
+ "rdkit/Chem/Pharm2D/UnitTestUtils.py": {
1915
+ "size": 9960
1916
+ },
1917
+ "rdkit/Chem/Pharm2D/Utils.py": {
1918
+ "size": 12973
1919
+ },
1920
+ "rdkit/Chem/Pharm2D/__init__.py": {
1921
+ "size": 1021
1922
+ },
1923
+ "rdkit/Chem/Pharm3D/EmbedLib.py": {
1924
+ "size": 41179
1925
+ },
1926
+ "rdkit/Chem/Pharm3D/ExcludedVolume.py": {
1927
+ "size": 918
1928
+ },
1929
+ "rdkit/Chem/Pharm3D/Pharmacophore.py": {
1930
+ "size": 5923
1931
+ },
1932
+ "rdkit/Chem/Pharm3D/UnitTestEmbed.py": {
1933
+ "size": 9408
1934
+ },
1935
+ "rdkit/Chem/Pharm3D/UnitTestExcludedVolume.py": {
1936
+ "size": 1177
1937
+ },
1938
+ "rdkit/Chem/Pharm3D/UnitTestPharmacophore.py": {
1939
+ "size": 5723
1940
+ },
1941
+ "rdkit/Chem/Pharm3D/__init__.py": {
1942
+ "size": 0
1943
+ },
1944
+ "rdkit/Chem/PropertyMol.py": {
1945
+ "size": 3161
1946
+ },
1947
+ "rdkit/Chem/PyMol.py": {
1948
+ "size": 8418
1949
+ },
1950
+ "rdkit/Chem/QED.py": {
1951
+ "size": 11472
1952
+ },
1953
+ "rdkit/Chem/Randomize.py": {
1954
+ "size": 1066
1955
+ },
1956
+ "rdkit/Chem/Recap.py": {
1957
+ "size": 20662
1958
+ },
1959
+ "rdkit/Chem/ReducedGraphs.py": {
1960
+ "size": 563
1961
+ },
1962
+ "rdkit/Chem/RegistrationHash.py": {
1963
+ "size": 13559
1964
+ },
1965
+ "rdkit/Chem/SATIS.py": {
1966
+ "size": 2806
1967
+ },
1968
+ "rdkit/Chem/SaltRemover.py": {
1969
+ "size": 10192
1970
+ },
1971
+ "rdkit/Chem/Scaffolds/MurckoScaffold.py": {
1972
+ "size": 4187
1973
+ },
1974
+ "rdkit/Chem/Scaffolds/UnitTestMurckoScaffold.py": {
1975
+ "size": 37853
1976
+ },
1977
+ "rdkit/Chem/Scaffolds/__init__.py": {
1978
+ "size": 0
1979
+ },
1980
+ "rdkit/Chem/ShowMols.py": {
1981
+ "size": 932
1982
+ },
1983
+ "rdkit/Chem/SimpleEnum/Enumerator.py": {
1984
+ "size": 9120
1985
+ },
1986
+ "rdkit/Chem/SimpleEnum/UnitTestEnumerator.py": {
1987
+ "size": 1445
1988
+ },
1989
+ "rdkit/Chem/SimpleEnum/__init__.py": {
1990
+ "size": 0
1991
+ },
1992
+ "rdkit/Chem/SpacialScore.py": {
1993
+ "size": 7118
1994
+ },
1995
+ "rdkit/Chem/Subshape/BuilderUtils.py": {
1996
+ "size": 10857
1997
+ },
1998
+ "rdkit/Chem/Subshape/SubshapeAligner.py": {
1999
+ "size": 13356
2000
+ },
2001
+ "rdkit/Chem/Subshape/SubshapeBuilder.py": {
2002
+ "size": 4205
2003
+ },
2004
+ "rdkit/Chem/Subshape/SubshapeObjects.py": {
2005
+ "size": 2451
2006
+ },
2007
+ "rdkit/Chem/Subshape/UnitTestSubshape.py": {
2008
+ "size": 3045
2009
+ },
2010
+ "rdkit/Chem/Subshape/__init__.py": {
2011
+ "size": 0
2012
+ },
2013
+ "rdkit/Chem/Subshape/demoCombined.py": {
2014
+ "size": 1797
2015
+ },
2016
+ "rdkit/Chem/Suppliers/DbMolSupplier.py": {
2017
+ "size": 3994
2018
+ },
2019
+ "rdkit/Chem/Suppliers/MolSupplier.py": {
2020
+ "size": 851
2021
+ },
2022
+ "rdkit/Chem/Suppliers/UnitTestDbMolSupplier.py": {
2023
+ "size": 2813
2024
+ },
2025
+ "rdkit/Chem/Suppliers/UnitTestSDMolSupplier.py": {
2026
+ "size": 6039
2027
+ },
2028
+ "rdkit/Chem/Suppliers/UnitTestSmilesMolSupplier.py": {
2029
+ "size": 3529
2030
+ },
2031
+ "rdkit/Chem/Suppliers/__init__.py": {
2032
+ "size": 0
2033
+ },
2034
+ "rdkit/Chem/TemplateAlign.py": {
2035
+ "size": 3191
2036
+ },
2037
+ "rdkit/Chem/TorsionFingerprints.py": {
2038
+ "size": 26572
2039
+ },
2040
+ "rdkit/Chem/UnitTestCatalog.py": {
2041
+ "size": 8761
2042
+ },
2043
+ "rdkit/Chem/UnitTestChem.py": {
2044
+ "size": 7279
2045
+ },
2046
+ "rdkit/Chem/UnitTestChemAtom.py": {
2047
+ "size": 1968
2048
+ },
2049
+ "rdkit/Chem/UnitTestChemBond.py": {
2050
+ "size": 1739
2051
+ },
2052
+ "rdkit/Chem/UnitTestChemSmarts.py": {
2053
+ "size": 1340
2054
+ },
2055
+ "rdkit/Chem/UnitTestChemv2.py": {
2056
+ "size": 5912
2057
+ },
2058
+ "rdkit/Chem/UnitTestCrippen.py": {
2059
+ "size": 5643
2060
+ },
2061
+ "rdkit/Chem/UnitTestDescriptors.py": {
2062
+ "size": 7678
2063
+ },
2064
+ "rdkit/Chem/UnitTestDocTestsChem.py": {
2065
+ "size": 1614
2066
+ },
2067
+ "rdkit/Chem/UnitTestEnumerateHeterocycles.py": {
2068
+ "size": 11759
2069
+ },
2070
+ "rdkit/Chem/UnitTestFeatFinderCLI.py": {
2071
+ "size": 2544
2072
+ },
2073
+ "rdkit/Chem/UnitTestFragmentDescriptors.py": {
2074
+ "size": 7976
2075
+ },
2076
+ "rdkit/Chem/UnitTestFunctionalGroups.py": {
2077
+ "size": 6345
2078
+ },
2079
+ "rdkit/Chem/UnitTestGraphDescriptors_2.py": {
2080
+ "size": 22329
2081
+ },
2082
+ "rdkit/Chem/UnitTestInchi.py": {
2083
+ "size": 12738
2084
+ },
2085
+ "rdkit/Chem/UnitTestLipinski.py": {
2086
+ "size": 6274
2087
+ },
2088
+ "rdkit/Chem/UnitTestMCS.py": {
2089
+ "size": 10891
2090
+ },
2091
+ "rdkit/Chem/UnitTestMol3D.py": {
2092
+ "size": 23548
2093
+ },
2094
+ "rdkit/Chem/UnitTestOldBugs.py": {
2095
+ "size": 3794
2096
+ },
2097
+ "rdkit/Chem/UnitTestPandasTools.py": {
2098
+ "size": 17804
2099
+ },
2100
+ "rdkit/Chem/UnitTestQED.py": {
2101
+ "size": 4460
2102
+ },
2103
+ "rdkit/Chem/UnitTestRandomize.py": {
2104
+ "size": 2772
2105
+ },
2106
+ "rdkit/Chem/UnitTestRegistrationHash.py": {
2107
+ "size": 30689
2108
+ },
2109
+ "rdkit/Chem/UnitTestSATIS.py": {
2110
+ "size": 1267
2111
+ },
2112
+ "rdkit/Chem/UnitTestSaltRemover.py": {
2113
+ "size": 5329
2114
+ },
2115
+ "rdkit/Chem/UnitTestSmiles.py": {
2116
+ "size": 8276
2117
+ },
2118
+ "rdkit/Chem/UnitTestSpacialScore.py": {
2119
+ "size": 2098
2120
+ },
2121
+ "rdkit/Chem/UnitTestSuppliers.py": {
2122
+ "size": 2721
2123
+ },
2124
+ "rdkit/Chem/UnitTestSurf.py": {
2125
+ "size": 8913
2126
+ },
2127
+ "rdkit/Chem/__init__.py": {
2128
+ "size": 9011
2129
+ },
2130
+ "rdkit/Chem/fmcs/__init__.py": {
2131
+ "size": 141
2132
+ },
2133
+ "rdkit/Chem/fmcs/fmcs.py": {
2134
+ "size": 105526
2135
+ },
2136
+ "rdkit/Chem/test_data/BuildCrippenTestSet.py": {
2137
+ "size": 989
2138
+ },
2139
+ "rdkit/Chem/test_data/BuildDescrsTestSet.Crippen.py": {
2140
+ "size": 1514
2141
+ },
2142
+ "rdkit/Chem/test_data/BuildDescrsTestSet.py": {
2143
+ "size": 1692
2144
+ },
2145
+ "rdkit/Chem/test_data/NCI_aromat_regress.txt": {
2146
+ "size": 449202
2147
+ },
2148
+ "rdkit/Chem/test_data/aromat_regress.txt": {
2149
+ "size": 393294
2150
+ },
2151
+ "rdkit/DataManip/Metric/__init__.py": {
2152
+ "size": 363
2153
+ },
2154
+ "rdkit/DataManip/__init__.py": {
2155
+ "size": 21
2156
+ },
2157
+ "rdkit/DataStructs/BitEnsemble.py": {
2158
+ "size": 1192
2159
+ },
2160
+ "rdkit/DataStructs/BitEnsembleDb.py": {
2161
+ "size": 1569
2162
+ },
2163
+ "rdkit/DataStructs/BitUtils.py": {
2164
+ "size": 1132
2165
+ },
2166
+ "rdkit/DataStructs/HierarchyVis.py": {
2167
+ "size": 3876
2168
+ },
2169
+ "rdkit/DataStructs/LazySignature.py": {
2170
+ "size": 1472
2171
+ },
2172
+ "rdkit/DataStructs/TopNContainer.py": {
2173
+ "size": 2037
2174
+ },
2175
+ "rdkit/DataStructs/UnitTestBitEnsemble.py": {
2176
+ "size": 4142
2177
+ },
2178
+ "rdkit/DataStructs/UnitTestDocTests.py": {
2179
+ "size": 3016
2180
+ },
2181
+ "rdkit/DataStructs/UnitTestTopNContainer.py": {
2182
+ "size": 2540
2183
+ },
2184
+ "rdkit/DataStructs/UnitTestcBitVect.py": {
2185
+ "size": 10995
2186
+ },
2187
+ "rdkit/DataStructs/VectCollection.py": {
2188
+ "size": 6411
2189
+ },
2190
+ "rdkit/DataStructs/__init__.py": {
2191
+ "size": 1600
2192
+ },
2193
+ "rdkit/Dbase/DbConnection.py": {
2194
+ "size": 7972
2195
+ },
2196
+ "rdkit/Dbase/DbInfo.py": {
2197
+ "size": 5332
2198
+ },
2199
+ "rdkit/Dbase/DbModule.py": {
2200
+ "size": 2069
2201
+ },
2202
+ "rdkit/Dbase/DbResultSet.py": {
2203
+ "size": 6093
2204
+ },
2205
+ "rdkit/Dbase/DbUtils.py": {
2206
+ "size": 13531
2207
+ },
2208
+ "rdkit/Dbase/StorageUtils.py": {
2209
+ "size": 7599
2210
+ },
2211
+ "rdkit/Dbase/UnitTestDbConnect.py": {
2212
+ "size": 7591
2213
+ },
2214
+ "rdkit/Dbase/UnitTestDbInfo.py": {
2215
+ "size": 1022
2216
+ },
2217
+ "rdkit/Dbase/UnitTestDbResultSet.py": {
2218
+ "size": 3711
2219
+ },
2220
+ "rdkit/Dbase/UnitTestDbUtils.py": {
2221
+ "size": 7354
2222
+ },
2223
+ "rdkit/Dbase/UnitTestStorageUtils.py": {
2224
+ "size": 1311
2225
+ },
2226
+ "rdkit/Dbase/__init__.py": {
2227
+ "size": 340
2228
+ },
2229
+ "rdkit/DistanceGeometry/__init__.py": {
2230
+ "size": 46
2231
+ },
2232
+ "rdkit/ForceField/__init__.py": {
2233
+ "size": 44
2234
+ },
2235
+ "rdkit/Geometry/__init__.py": {
2236
+ "size": 109
2237
+ },
2238
+ "rdkit/ML/Cluster/Butina.py": {
2239
+ "size": 5547
2240
+ },
2241
+ "rdkit/ML/Cluster/ClusterUtils.py": {
2242
+ "size": 4413
2243
+ },
2244
+ "rdkit/ML/Cluster/ClusterVis.py": {
2245
+ "size": 15378
2246
+ },
2247
+ "rdkit/ML/Cluster/Clusters.py": {
2248
+ "size": 7805
2249
+ },
2250
+ "rdkit/ML/Cluster/Murtagh.py": {
2251
+ "size": 3099
2252
+ },
2253
+ "rdkit/ML/Cluster/Resemblance.py": {
2254
+ "size": 3251
2255
+ },
2256
+ "rdkit/ML/Cluster/Standardize.py": {
2257
+ "size": 675
2258
+ },
2259
+ "rdkit/ML/Cluster/UnitTestButina.py": {
2260
+ "size": 4414
2261
+ },
2262
+ "rdkit/ML/Cluster/UnitTestCluster.py": {
2263
+ "size": 6146
2264
+ },
2265
+ "rdkit/ML/Cluster/__init__.py": {
2266
+ "size": 0
2267
+ },
2268
+ "rdkit/ML/Cluster/murtagh_test.py": {
2269
+ "size": 882
2270
+ },
2271
+ "rdkit/ML/Data/DataUtils.py": {
2272
+ "size": 17686
2273
+ },
2274
+ "rdkit/ML/Data/FindQuantBounds.py": {
2275
+ "size": 1653
2276
+ },
2277
+ "rdkit/ML/Data/MLData.py": {
2278
+ "size": 10430
2279
+ },
2280
+ "rdkit/ML/Data/Quantize.py": {
2281
+ "size": 10595
2282
+ },
2283
+ "rdkit/ML/Data/SplitData.py": {
2284
+ "size": 8814
2285
+ },
2286
+ "rdkit/ML/Data/Stats.py": {
2287
+ "size": 7089
2288
+ },
2289
+ "rdkit/ML/Data/Transforms.py": {
2290
+ "size": 877
2291
+ },
2292
+ "rdkit/ML/Data/UnitTestDoctests.py": {
2293
+ "size": 1509
2294
+ },
2295
+ "rdkit/ML/Data/UnitTestFilter.py": {
2296
+ "size": 3656
2297
+ },
2298
+ "rdkit/ML/Data/UnitTestMLData.py": {
2299
+ "size": 7092
2300
+ },
2301
+ "rdkit/ML/Data/UnitTestQuantize.py": {
2302
+ "size": 10936
2303
+ },
2304
+ "rdkit/ML/Data/UnitTestStats.py": {
2305
+ "size": 5969
2306
+ },
2307
+ "rdkit/ML/Data/__init__.py": {
2308
+ "size": 0
2309
+ },
2310
+ "rdkit/ML/Data/test_data/populate.py": {
2311
+ "size": 683
2312
+ },
2313
+ "rdkit/ML/Descriptors/CompoundDescriptors.py": {
2314
+ "size": 14135
2315
+ },
2316
+ "rdkit/ML/Descriptors/Descriptors.py": {
2317
+ "size": 1553
2318
+ },
2319
+ "rdkit/ML/Descriptors/MoleculeDescriptors.py": {
2320
+ "size": 3244
2321
+ },
2322
+ "rdkit/ML/Descriptors/Parser.py": {
2323
+ "size": 12428
2324
+ },
2325
+ "rdkit/ML/Descriptors/UnitTestDescriptors.py": {
2326
+ "size": 1661
2327
+ },
2328
+ "rdkit/ML/Descriptors/UnitTestMolDescriptors.py": {
2329
+ "size": 3116
2330
+ },
2331
+ "rdkit/ML/Descriptors/UnitTestParser.py": {
2332
+ "size": 1862
2333
+ },
2334
+ "rdkit/ML/Descriptors/__init__.py": {
2335
+ "size": 0
2336
+ },
2337
+ "rdkit/ML/InfoTheory/BitClusterer.py": {
2338
+ "size": 2321
2339
+ },
2340
+ "rdkit/ML/InfoTheory/BitRank.py": {
2341
+ "size": 5481
2342
+ },
2343
+ "rdkit/ML/InfoTheory/UnitTestBitRanker.py": {
2344
+ "size": 4211
2345
+ },
2346
+ "rdkit/ML/InfoTheory/UnitTestCorrMatGen.py": {
2347
+ "size": 3954
2348
+ },
2349
+ "rdkit/ML/InfoTheory/__init__.py": {
2350
+ "size": 89
2351
+ },
2352
+ "rdkit/ML/InfoTheory/entropy.py": {
2353
+ "size": 2820
2354
+ },
2355
+ "rdkit/ML/MLUtils/VoteImg.py": {
2356
+ "size": 6032
2357
+ },
2358
+ "rdkit/ML/MLUtils/__init__.py": {
2359
+ "size": 0
2360
+ },
2361
+ "rdkit/ML/MatOps.py": {
2362
+ "size": 774
2363
+ },
2364
+ "rdkit/ML/SLT/Risk.py": {
2365
+ "size": 3059
2366
+ },
2367
+ "rdkit/ML/SLT/UnitTestRisk.py": {
2368
+ "size": 1771
2369
+ },
2370
+ "rdkit/ML/SLT/__init__.py": {
2371
+ "size": 0
2372
+ },
2373
+ "rdkit/ML/Scoring/Scoring.py": {
2374
+ "size": 6387
2375
+ },
2376
+ "rdkit/ML/Scoring/UnitTestScoring.py": {
2377
+ "size": 6644
2378
+ },
2379
+ "rdkit/ML/Scoring/__init__.py": {
2380
+ "size": 0
2381
+ },
2382
+ "rdkit/ML/__init__.py": {
2383
+ "size": 340
2384
+ },
2385
+ "rdkit/ML/files.py": {
2386
+ "size": 2483
2387
+ },
2388
+ "rdkit/ML/test_data/populate.py": {
2389
+ "size": 13967
2390
+ },
2391
+ "rdkit/Numerics/__init__.py": {
2392
+ "size": 91
2393
+ },
2394
+ "rdkit/RDConfig.py": {
2395
+ "size": 2153
2396
+ },
2397
+ "rdkit/RDLogger.py": {
2398
+ "size": 1612
2399
+ },
2400
+ "rdkit/RDRandom.py": {
2401
+ "size": 1602
2402
+ },
2403
+ "rdkit/SimDivFilters/SimilarityPickers.py": {
2404
+ "size": 7305
2405
+ },
2406
+ "rdkit/SimDivFilters/UnitTestSimilarityPickers.py": {
2407
+ "size": 2760
2408
+ },
2409
+ "rdkit/SimDivFilters/__init__.py": {
2410
+ "size": 253
2411
+ },
2412
+ "rdkit/SimDivFilters/test_data/genfps.py": {
2413
+ "size": 618
2414
+ },
2415
+ "rdkit/TestRunner.py": {
2416
+ "size": 3608
2417
+ },
2418
+ "rdkit/UnitTestLogging.py": {
2419
+ "size": 11945
2420
+ },
2421
+ "rdkit/VLib/Filter.py": {
2422
+ "size": 2728
2423
+ },
2424
+ "rdkit/VLib/Node.py": {
2425
+ "size": 4558
2426
+ },
2427
+ "rdkit/VLib/NodeLib/DbMolSupply.py": {
2428
+ "size": 1679
2429
+ },
2430
+ "rdkit/VLib/NodeLib/DbPickleSupplier.py": {
2431
+ "size": 5746
2432
+ },
2433
+ "rdkit/VLib/NodeLib/SDSupply.py": {
2434
+ "size": 1397
2435
+ },
2436
+ "rdkit/VLib/NodeLib/SmartsMolFilter.py": {
2437
+ "size": 2668
2438
+ },
2439
+ "rdkit/VLib/NodeLib/SmartsRemover.py": {
2440
+ "size": 3877
2441
+ },
2442
+ "rdkit/VLib/NodeLib/SmilesDupeFilter.py": {
2443
+ "size": 1497
2444
+ },
2445
+ "rdkit/VLib/NodeLib/SmilesOutput.py": {
2446
+ "size": 1995
2447
+ },
2448
+ "rdkit/VLib/NodeLib/SmilesSupply.py": {
2449
+ "size": 1899
2450
+ },
2451
+ "rdkit/VLib/NodeLib/UnitTestNodeLib.py": {
2452
+ "size": 3489
2453
+ },
2454
+ "rdkit/VLib/NodeLib/__init__.py": {
2455
+ "size": 95
2456
+ },
2457
+ "rdkit/VLib/NodeLib/demo.py": {
2458
+ "size": 1986
2459
+ },
2460
+ "rdkit/VLib/NodeLib/test_data/pgp_20.txt": {
2461
+ "size": 2158
2462
+ },
2463
+ "rdkit/VLib/Output.py": {
2464
+ "size": 1651
2465
+ },
2466
+ "rdkit/VLib/Supply.py": {
2467
+ "size": 1501
2468
+ },
2469
+ "rdkit/VLib/Transform.py": {
2470
+ "size": 2041
2471
+ },
2472
+ "rdkit/VLib/UnitTestVLib.py": {
2473
+ "size": 4542
2474
+ },
2475
+ "rdkit/VLib/__init__.py": {
2476
+ "size": 13
2477
+ },
2478
+ "rdkit/__init__.py": {
2479
+ "size": 1838
2480
+ },
2481
+ "rdkit/conftest.py": {
2482
+ "size": 582
2483
+ },
2484
+ "rdkit/pytest.ini": {
2485
+ "size": 627
2486
+ },
2487
+ "rdkit/sping/PDF/__init__.py": {
2488
+ "size": 22
2489
+ },
2490
+ "rdkit/sping/PDF/pdfdoc.py": {
2491
+ "size": 15541
2492
+ },
2493
+ "rdkit/sping/PDF/pdfgen.py": {
2494
+ "size": 38180
2495
+ },
2496
+ "rdkit/sping/PDF/pdfgeom.py": {
2497
+ "size": 2413
2498
+ },
2499
+ "rdkit/sping/PDF/pdfmetrics.py": {
2500
+ "size": 20538
2501
+ },
2502
+ "rdkit/sping/PDF/pdfutils.py": {
2503
+ "size": 9789
2504
+ },
2505
+ "rdkit/sping/PDF/pidPDF.py": {
2506
+ "size": 23117
2507
+ },
2508
+ "rdkit/sping/PIL/__init__.py": {
2509
+ "size": 32
2510
+ },
2511
+ "rdkit/sping/PIL/pidPIL.py": {
2512
+ "size": 14301
2513
+ },
2514
+ "rdkit/sping/PIL/pilfonts/removemedium.py": {
2515
+ "size": 212
2516
+ },
2517
+ "rdkit/sping/PS/__init__.py": {
2518
+ "size": 31
2519
+ },
2520
+ "rdkit/sping/PS/fontinfo.py": {
2521
+ "size": 334
2522
+ },
2523
+ "rdkit/sping/PS/latin1MetricsCache.py": {
2524
+ "size": 19078
2525
+ },
2526
+ "rdkit/sping/PS/pidPS.py": {
2527
+ "size": 34776
2528
+ },
2529
+ "rdkit/sping/PS/psmetrics.py": {
2530
+ "size": 17626
2531
+ },
2532
+ "rdkit/sping/Pyart/Fontmapping.py": {
2533
+ "size": 3163
2534
+ },
2535
+ "rdkit/sping/Pyart/__init__.py": {
2536
+ "size": 40
2537
+ },
2538
+ "rdkit/sping/Pyart/pidPyart.py": {
2539
+ "size": 8275
2540
+ },
2541
+ "rdkit/sping/Qt/__init__.py": {
2542
+ "size": 0
2543
+ },
2544
+ "rdkit/sping/Qt/pidQt.py": {
2545
+ "size": 11206
2546
+ },
2547
+ "rdkit/sping/Qt/pidQt4.py": {
2548
+ "size": 10672
2549
+ },
2550
+ "rdkit/sping/ReportLab/__init__.py": {
2551
+ "size": 0
2552
+ },
2553
+ "rdkit/sping/ReportLab/pidReportLab.py": {
2554
+ "size": 10405
2555
+ },
2556
+ "rdkit/sping/SVG/__init__.py": {
2557
+ "size": 44
2558
+ },
2559
+ "rdkit/sping/SVG/pidSVG.py": {
2560
+ "size": 23674
2561
+ },
2562
+ "rdkit/sping/TK/__init__.py": {
2563
+ "size": 20
2564
+ },
2565
+ "rdkit/sping/TK/pidTK.py": {
2566
+ "size": 16409
2567
+ },
2568
+ "rdkit/sping/WX/__init__.py": {
2569
+ "size": 20
2570
+ },
2571
+ "rdkit/sping/WX/pidWX.py": {
2572
+ "size": 12753
2573
+ },
2574
+ "rdkit/sping/WX/pidWxDc.py": {
2575
+ "size": 8750
2576
+ },
2577
+ "rdkit/sping/__init__.py": {
2578
+ "size": 154
2579
+ },
2580
+ "rdkit/sping/colors.py": {
2581
+ "size": 6935
2582
+ },
2583
+ "rdkit/sping/examples/formatted-strings.py": {
2584
+ "size": 1270
2585
+ },
2586
+ "rdkit/sping/examples/tkCanvas-with-scrollbars.py": {
2587
+ "size": 2609
2588
+ },
2589
+ "rdkit/sping/examples/tkCanvasPIL-with-scrollbars.py": {
2590
+ "size": 2603
2591
+ },
2592
+ "rdkit/sping/pagesizes.py": {
2593
+ "size": 600
2594
+ },
2595
+ "rdkit/sping/pid.py": {
2596
+ "size": 21546
2597
+ },
2598
+ "rdkit/sping/stringformat.py": {
2599
+ "size": 17930
2600
+ },
2601
+ "rdkit/sping/tests/__init__.py": {
2602
+ "size": 26
2603
+ },
2604
+ "rdkit/sping/tests/pidtest.py": {
2605
+ "size": 14492
2606
+ },
2607
+ "rdkit/sping/tests/pstests.py": {
2608
+ "size": 425
2609
+ },
2610
+ "rdkit/sping/tests/testallps.py": {
2611
+ "size": 972
2612
+ },
2613
+ "rdkit/sping/util/HTMLPiddler.py": {
2614
+ "size": 12489
2615
+ },
2616
+ "rdkit/sping/util/__init__.py": {
2617
+ "size": 16
2618
+ },
2619
+ "rdkit/sping/utils.py": {
2620
+ "size": 318
2621
+ },
2622
+ "rdkit/utils/UnitTestUtils.py": {
2623
+ "size": 2273
2624
+ },
2625
+ "rdkit/utils/__init__.py": {
2626
+ "size": 0
2627
+ },
2628
+ "rdkit/utils/cactvs.py": {
2629
+ "size": 1788
2630
+ },
2631
+ "rdkit/utils/chemdraw.py": {
2632
+ "size": 11838
2633
+ },
2634
+ "rdkit/utils/chemdraw_qax.py": {
2635
+ "size": 2490
2636
+ },
2637
+ "rdkit/utils/chemutils.py": {
2638
+ "size": 4633
2639
+ },
2640
+ "rdkit/utils/fileutils.py": {
2641
+ "size": 1003
2642
+ },
2643
+ "rdkit/utils/listutils.py": {
2644
+ "size": 1189
2645
+ },
2646
+ "rdkit/utils/retest.txt": {
2647
+ "size": 113
2648
+ },
2649
+ "rdkit/utils/spiral.py": {
2650
+ "size": 1837
2651
+ },
2652
+ "setup.cfg": {
2653
+ "size": 645
2654
+ }
2655
+ },
2656
+ "processed_by": "zip_fallback",
2657
+ "success": true
2658
+ },
2659
+ "structure": {
2660
+ "packages": [
2661
+ "source.Contrib.RxnRoleAssignment",
2662
+ "source.Scripts.gen_rdkit_stubs",
2663
+ "source.Scripts.patch_rdkit_docstrings",
2664
+ "source.rdkit",
2665
+ "source.rdkit.Avalon",
2666
+ "source.rdkit.Chem",
2667
+ "source.rdkit.DataManip",
2668
+ "source.rdkit.DataStructs",
2669
+ "source.rdkit.Dbase",
2670
+ "source.rdkit.DistanceGeometry",
2671
+ "source.rdkit.ForceField",
2672
+ "source.rdkit.Geometry",
2673
+ "source.rdkit.ML",
2674
+ "source.rdkit.Numerics",
2675
+ "source.rdkit.SimDivFilters",
2676
+ "source.rdkit.VLib",
2677
+ "source.rdkit.sping",
2678
+ "source.rdkit.utils"
2679
+ ]
2680
+ },
2681
+ "dependencies": {
2682
+ "has_environment_yml": false,
2683
+ "has_requirements_txt": false,
2684
+ "pyproject": false,
2685
+ "setup_cfg": true,
2686
+ "setup_py": false
2687
+ },
2688
+ "entry_points": {
2689
+ "imports": [],
2690
+ "cli": [],
2691
+ "modules": []
2692
+ },
2693
+ "llm_analysis": {
2694
+ "core_modules": [
2695
+ {
2696
+ "package": "source.rdkit.Chem",
2697
+ "module": "AllChem",
2698
+ "functions": [
2699
+ "MolFromSmiles",
2700
+ "MolToSmiles",
2701
+ "AddHs",
2702
+ "RemoveHs"
2703
+ ],
2704
+ "classes": [
2705
+ "Mol",
2706
+ "Atom",
2707
+ "Bond"
2708
+ ],
2709
+ "description": "Core module for chemical informatics, providing functions for molecule manipulation and conversion."
2710
+ },
2711
+ {
2712
+ "package": "source.rdkit.Chem",
2713
+ "module": "Descriptors",
2714
+ "functions": [
2715
+ "CalcMolWt",
2716
+ "CalcExactMolWt",
2717
+ "CalcNumHBA",
2718
+ "CalcNumHBD"
2719
+ ],
2720
+ "classes": [],
2721
+ "description": "Module for calculating molecular descriptors such as molecular weight, hydrogen bond acceptors, and donors."
2722
+ },
2723
+ {
2724
+ "package": "source.rdkit.Chem",
2725
+ "module": "Draw",
2726
+ "functions": [
2727
+ "MolToImage",
2728
+ "MolToImageFile",
2729
+ "MolToImageBytes"
2730
+ ],
2731
+ "classes": [
2732
+ "MolDrawOptions"
2733
+ ],
2734
+ "description": "Module for visualizing molecules as images."
2735
+ },
2736
+ {
2737
+ "package": "source.rdkit.ML.Cluster",
2738
+ "module": "Butina",
2739
+ "functions": [
2740
+ "ClusterData"
2741
+ ],
2742
+ "classes": [],
2743
+ "description": "Module for clustering data using the Butina algorithm."
2744
+ },
2745
+ {
2746
+ "package": "source.rdkit.DataStructs",
2747
+ "module": "BitUtils",
2748
+ "functions": [
2749
+ "OnBitsFromBits",
2750
+ "BitsToText"
2751
+ ],
2752
+ "classes": [],
2753
+ "description": "Module for handling bit vector operations."
2754
+ }
2755
+ ],
2756
+ "cli_commands": [
2757
+ {
2758
+ "name": "FeatFinderCLI",
2759
+ "module": "source.rdkit.Chem.FeatFinderCLI",
2760
+ "description": "Command-line interface for finding chemical features in molecules."
2761
+ },
2762
+ {
2763
+ "name": "run_python_tests",
2764
+ "module": "source.Scripts.run_python_tests",
2765
+ "description": "Command-line tool for running Python tests in the RDKit repository."
2766
+ }
2767
+ ],
2768
+ "import_strategy": {
2769
+ "primary": "import",
2770
+ "fallback": "blackbox",
2771
+ "confidence": 0.9
2772
+ },
2773
+ "dependencies": {
2774
+ "required": [
2775
+ "numpy",
2776
+ "pandas",
2777
+ "matplotlib",
2778
+ "scipy"
2779
+ ],
2780
+ "optional": [
2781
+ "pillow",
2782
+ "pytest",
2783
+ "jupyter"
2784
+ ]
2785
+ },
2786
+ "risk_assessment": {
2787
+ "import_feasibility": 0.85,
2788
+ "intrusiveness_risk": "low",
2789
+ "complexity": "medium"
2790
+ }
2791
+ },
2792
+ "deepwiki_analysis": {
2793
+ "repo_url": "https://github.com/rdkit/rdkit",
2794
+ "repo_name": "rdkit",
2795
+ "content": "rdkit/rdkit\nInstallation and Build System\nArchitecture Overview\nCore Molecular System\nMolecular Data Structures\nMolecular Operations and Sanitization\nStereochemistry and Chirality\nPython Bindings for Core Objects\nInput/Output and Serialization\nSMILES and SMARTS Processing\nFile Format Support\nMolecule Suppliers and Writers\nVisualization and Rendering\n2D Molecular Drawing System\nPython Drawing Integration\n3D Structure and Geometry\n3D Conformer Generation\nChemical Analysis and Descriptors\nMolecular Descriptors and Properties\nMolecular Fingerprints\nMaximum Common Substructure\nChemical Transformations\nChemical Reactions\nMolecular Fragmentation and Transforms\nR-Group Decomposition\nData Integration and External Systems\nPython API and Core Integration\nPandas Integration\nPostgreSQL Chemical Cartridge\nJavaScript and Web Integration\nJava and C# Bindings\n.travis.yml\nCMakeLists.txt\nCode/GraphMol/CMakeLists.txt\nCode/GraphMol/FileParsers/CMakeLists.txt\nCode/GraphMol/Trajectory/CMakeLists.txt\nCode/GraphMol/Wrap/CMakeLists.txt\nCode/GraphMol/Wrap/rdchem.cpp\nCode/GraphMol/Wrap/testThreads.py\nCode/RDBoost/CMakeLists.txt\nCode/RDBoost/Wrap.cpp\nCode/RDBoost/Wrap.h\nCode/RDGeneral/CMakeLists.txt\nCode/RDGeneral/LocaleSwitcher.h\nCode/RDGeneral/versions.cpp.cmake\nCode/RDGeneral/versions.h.cmake\nCode/cmake/Modules/FindEigen3.cmake\nCode/cmake/Modules/RDKitUtils.cmake\nDocs/Book/BackwardsIncompatibleChanges.md\nDocs/Book/GettingStartedInPython.rst\nDocs/Book/Install.md\nDocs/Book/Makefile\nDocs/Book/Overview.md\nDocs/Book/conf.py\nDocs/Book/images/query_atoms.png\nDocs/Book/images/query_bonds.2.png\nDocs/Book/images/query_bonds.png\nDocs/Book/index.rst\nDocs/Book/source/rdkit.Chem.RegistrationHash.rst\nDocs/Book/source/rdkit.Chem.rdEnumerateStereoisomers.rst\nDocs/Book/source/rdkit.Chem.rdGeneralizedSubstruct.rst\nDocs/Book/source/rdkit.Chem.rdMIF.rst\nDocs/Book/source/rdkit.Chem.rdMolProcessing.rst\nDocs/Book/source/rdkit.Chem.rdRascalMCES.rst\nDocs/Book/source/rdkit.Chem.rdSynthonSpaceSearch.rst\nDocs/Book/source/rdkit.Chem.rst\nReleaseNotes.md\nThe RDKit is a comprehensive open-source cheminformatics and machine learning toolkit written in C++ with Python wrappers. It provides a rich set of functionality for working with chemical structures, including molecular representation, file parsing, substructure searching, molecular descriptor calculation, fingerprinting, 2D/3D structure visualization, and chemical reactions.\nThis page introduces the core concepts, architecture, and key capabilities of RDKit. For specific installation instructions, seeInstallation and Build System. For a deeper dive into the technical aspects of RDKit's design, seeArchitecture Overview.\nCore Capabilities\nRDKit offers a wide range of chemical informatics functionality:\nReading and writing molecules in various formats (SMILES, Molfiles, etc.)\nMolecular property calculation and descriptor generation\nSubstructure searching\nMolecular fingerprinting\n2D and 3D structure visualization\nChemical reaction handling\nMolecular conformer generation\nForce field implementations\nMolecular alignment and shape comparison\nScaffold analysis\nMaximum common substructure detection\nMachine learning integration\nSources:ReleaseNotes.md30-57README.md6-10CMakeLists.txt22-72\nSoftware Architecture\nHigh-Level Architecture\nThe RDKit is built around a core set of C++ libraries, with Python wrappers providing a user-friendly interface. The system is highly modular, allowing users to include only the functionality they need.\nExternal InterfacesPython InterfaceCore C++ LibrariesCore Molecule Representation(ROMol, RWMol, Atom, Bond)Input/Output(SMILES, Molfiles, SDF, etc.)Molecular Operations(Sanitization, Hydrogens, etc.)Substructure SearchingMolecular Properties(Descriptors, Fingerprints)2D/3D Visualization3D Operations(Conformers, Force Fields)Chemical Reactionsrdkit Python Packagerdkit.Chem(Core Functionality)rdkit.Chem.AllChem(Advanced Features)rdkit.Chem.Draw(Visualization)rdkit.DataStructs(Fingerprints, Similarity)rdkit.ML(Machine Learning)PostgreSQL CartridgeJavaScript Bindings\nExternal Interfaces\nPython Interface\nCore C++ Libraries\nCore Molecule Representation(ROMol, RWMol, Atom, Bond)\nInput/Output(SMILES, Molfiles, SDF, etc.)\nMolecular Operations(Sanitization, Hydrogens, etc.)\nSubstructure Searching\nMolecular Properties(Descriptors, Fingerprints)\n2D/3D Visualization\n3D Operations(Conformers, Force Fields)\nChemical Reactions\nrdkit Python Package\nrdkit.Chem(Core Functionality)\nrdkit.Chem.AllChem(Advanced Features)\nrdkit.Chem.Draw(Visualization)\nrdkit.DataStructs(Fingerprints, Similarity)\nrdkit.ML(Machine Learning)\nPostgreSQL Cartridge\nJavaScript Bindings\nSources:CMakeLists.txt1-121Code/GraphMol/CMakeLists.txt1-50ReleaseNotes.md30-57\nCore Molecular Representation\nAt the heart of RDKit is the molecule representation, withROMol(Read-Only Molecule) as the foundational class andRWMol(Read-Write Molecule) for modifiable structures. Atoms, bonds, and properties form the basic components of molecular graphs.\n1111manymanymany1RDProps+setProp(key, val)+getProp(key)+hasProp(key)+clearProp(key)ROMol+getNumAtoms()+getAtomWithIdx(idx)+getBondWithIdx(idx)+getAtoms()+getBonds()+getConformer(id)+getNumConformers()RWMol+addAtom(atom)+addBond(beginAtomIdx, endAtomIdx, bondType)+removeAtom(atom)+removeBond(beginAtomIdx, endAtomIdx)Atom+getAtomicNum()+getFormalCharge()+getIdx()+getImplicitValence()+getExplicitValence()+getNumImplicitHs()+getIsAromatic()+getChiralTag()Bond+getBondType()+getBeginAtomIdx()+getEndAtomIdx()+getIsAromatic()+getStereo()Conformer+getNumAtoms()+getAtomPos(idx)+setAtomPos(idx, point)+getId()RingInfo+numRings()+atomRings()+bondRings()+isAtomInRingOfSize(idx, size)+isBondInRingOfSize(idx, size)\n+setProp(key, val)\n+getProp(key)\n+hasProp(key)\n+clearProp(key)\n+getNumAtoms()\n+getAtomWithIdx(idx)\n+getBondWithIdx(idx)\n+getAtoms()\n+getBonds()\n+getConformer(id)\n+getNumConformers()\n+addAtom(atom)\n+addBond(beginAtomIdx, endAtomIdx, bondType)\n+removeAtom(atom)\n+removeBond(beginAtomIdx, endAtomIdx)\n+getAtomicNum()\n+getFormalCharge()\n+getImplicitValence()\n+getExplicitValence()\n+getNumImplicitHs()\n+getIsAromatic()\n+getChiralTag()\n+getBondType()\n+getBeginAtomIdx()\n+getEndAtomIdx()\n+getIsAromatic()\n+getStereo()\n+getNumAtoms()\n+getAtomPos(idx)\n+setAtomPos(idx, point)\n+numRings()\n+atomRings()\n+bondRings()\n+isAtomInRingOfSize(idx, size)\n+isBondInRingOfSize(idx, size)\nSources:Code/GraphMol/ROMol.h1-100Code/GraphMol/RWMol.cpp1-100Code/GraphMol/Atom.h1-100Code/GraphMol/molopstest.cpp3-50\nKey Processing Workflows\nRDKit supports several common workflows for processing molecular data:\n1. Molecule Reading and Manipulation\nInput(SMILES, Molfile, etc.)Parse/Read(MolFromSmiles, MolFromMolFile)ROMol/RWMolObjectSanitize(MolOps::sanitizeMol)Modify(Add/Remove Hs, etc.)Analyze(Calculate Properties)Output(SMILES, Molfile, Visualization)\nInput(SMILES, Molfile, etc.)\nParse/Read(MolFromSmiles, MolFromMolFile)\nROMol/RWMolObject\nSanitize(MolOps::sanitizeMol)\nModify(Add/Remove Hs, etc.)\nAnalyze(Calculate Properties)\nOutput(SMILES, Molfile, Visualization)\nSources:Docs/Book/GettingStartedInPython.rst42-400Code/GraphMol/Wrap/MolOps.cpp401-420\n2. Substructure Searching\nTarget Molecule(ROMol)Prepare(Sanitize, Add Hs)Query Pattern(SMARTS, ROMol)Parse Query(MolFromSmarts)Substructure Match(SubstructMatch)Match Results(Atom Indices)Process Results(Filter, Highlight, etc.)\nTarget Molecule(ROMol)\nPrepare(Sanitize, Add Hs)\nQuery Pattern(SMARTS, ROMol)\nParse Query(MolFromSmarts)\nSubstructure Match(SubstructMatch)\nMatch Results(Atom Indices)\nProcess Results(Filter, Highlight, etc.)\nSources:Docs/Book/GettingStartedInPython.rst363-400Code/GraphMol/molopstest.cpp313-335\nUsing RDKit\nRDKit can be used from both Python and C++, with most users preferring the Python interface for its ease of use. Here's a basic workflow table showing common operations:\nmol = Chem.MolFromSmiles('c1ccccc1')\nROMol *mol = SmilesToMol(\"c1ccccc1\");\nsmiles = Chem.MolToSmiles(mol)\nstd::string smiles = MolToSmiles(*mol);\nmol_with_h = Chem.AddHs(mol)\nROMol *mol_with_h = MolOps::addHs(*mol);\nfp = AllChem.GetMorganFingerprintAsBitVect(mol, 2)\nMorganFingerprints::getFingerprintAsBitVect(*mol, 2, fingerprint);\nimg = Draw.MolToImage(mol)\nmatches = mol.GetSubstructMatches(query)\nstd::vector<MatchVectType> matches; SubstructMatch(*mol, *query, matches);\nSources:Docs/Book/GettingStartedInPython.rst42-147Code/GraphMol/Wrap/rough_test.py45-300Code/GraphMol/test1.cpp20-100\nMajor Components\nRDKit consists of numerous components, each providing specific functionality:\nMolFromSmiles\nMolToSmiles\nMolFromSmarts\nMolFromMolFile\nMolToMolFile\nSDMolSupplier\nSubstructMatch\nCompute2DCoords\nEmbedMolecule\nChemicalReaction\nReactionFromSmarts\nSources:Code/GraphMol/CMakeLists.txt1-129ReleaseNotes.md50-175\nIntegration Points\nRDKit can be integrated with other systems and languages:\nPython Ecosystem: Seamless integration with NumPy, pandas, Jupyter, scikit-learn",
2796
+ "model": "gpt-4o",
2797
+ "source": "selenium",
2798
+ "success": true
2799
+ },
2800
+ "deepwiki_options": {
2801
+ "enabled": true,
2802
+ "model": "gpt-4o"
2803
+ },
2804
+ "risk": {
2805
+ "import_feasibility": 0.85,
2806
+ "intrusiveness_risk": "low",
2807
+ "complexity": "medium"
2808
+ }
2809
+ }
rdkit/mcp_output/env_info.json ADDED
@@ -0,0 +1,15 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "environment": {
3
+ "type": "conda",
4
+ "name": "rdkit_850480_env",
5
+ "files": {},
6
+ "python": "3.10",
7
+ "exec_prefix": []
8
+ },
9
+ "original_tests": {
10
+ "passed": false,
11
+ "report_path": null
12
+ },
13
+ "timestamp": 1758850567.244021,
14
+ "conda_available": true
15
+ }
rdkit/mcp_output/mcp_logs/llm_statistics.json ADDED
@@ -0,0 +1,11 @@
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "total_calls": 4,
3
+ "failed_calls": 0,
4
+ "retry_count": 0,
5
+ "total_prompt_tokens": 85483,
6
+ "total_completion_tokens": 4230,
7
+ "total_tokens": 89713,
8
+ "average_prompt_tokens": 21370.75,
9
+ "average_completion_tokens": 1057.5,
10
+ "average_tokens": 22428.25
11
+ }
rdkit/mcp_output/mcp_logs/run_log.json ADDED
@@ -0,0 +1,74 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "timestamp": 1758850704.982304,
3
+ "node": "RunNode",
4
+ "test_result": {
5
+ "passed": false,
6
+ "report_path": null,
7
+ "stdout": "",
8
+ "stderr": "ERROR conda.cli.main_run:execute(41): `conda run python mcp_output/start_mcp.py` failed. (See above for error)\nTraceback (most recent call last):\n File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/start_mcp.py\", line 17, in <module>\n from mcp_service import create_app\n File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/mcp_plugin/mcp_service.py\", line 8, in <module>\n from rdkit.Chem import FeatFinderCLI\n File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/source/rdkit/__init__.py\", line 6, in <module>\n from . import rdBase\nImportError: cannot import name 'rdBase' from partially initialized module 'rdkit' (most likely due to a circular import) (/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/source/rdkit/__init__.py)\n\n"
9
+ },
10
+ "run_result": {
11
+ "success": false,
12
+ "test_passed": false,
13
+ "exit_code": 1,
14
+ "stdout": "",
15
+ "stderr": "ERROR conda.cli.main_run:execute(41): `conda run python mcp_output/start_mcp.py` failed. (See above for error)\nTraceback (most recent call last):\n File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/start_mcp.py\", line 17, in <module>\n from mcp_service import create_app\n File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/mcp_plugin/mcp_service.py\", line 8, in <module>\n from rdkit.Chem import FeatFinderCLI\n File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/source/rdkit/__init__.py\", line 6, in <module>\n from . import rdBase\nImportError: cannot import name 'rdBase' from partially initialized module 'rdkit' (most likely due to a circular import) (/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/source/rdkit/__init__.py)\n\n",
16
+ "timestamp": 1758850704.9821641,
17
+ "error_type": "ImportError",
18
+ "error": "Import error: ERROR conda.cli.main_run:execute(41): `conda run python mcp_output/start_mcp.py` failed. (See above for error)\nTraceback (most recent call last):\n File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/start_mcp.py\", line 17, in <module>\n from mcp_service import create_app\n File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/mcp_plugin/mcp_service.py\", line 8, in <module>\n from rdkit.Chem import FeatFinderCLI\n File \"/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/source/rdkit/__init__.py\", line 6, in <module>\n from . import rdBase\nImportError: cannot import name 'rdBase' from partially initialized module 'rdkit' (most likely due to a circular import) (/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/source/rdkit/__init__.py)\n\n",
19
+ "details": {
20
+ "command": "/home/wshiah/code/miniconda3/bin/conda run -n rdkit_850480_env --cwd /export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit python mcp_output/start_mcp.py",
21
+ "working_directory": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit",
22
+ "environment_type": "conda"
23
+ }
24
+ },
25
+ "environment": {
26
+ "type": "conda",
27
+ "name": "rdkit_850480_env",
28
+ "files": {},
29
+ "python": "3.10",
30
+ "exec_prefix": []
31
+ },
32
+ "plugin_info": {
33
+ "files": {
34
+ "mcp_output/start_mcp.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/start_mcp.py",
35
+ "mcp_output/mcp_plugin/__init__.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/mcp_plugin/__init__.py",
36
+ "mcp_output/mcp_plugin/mcp_service.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/mcp_plugin/mcp_service.py",
37
+ "mcp_output/mcp_plugin/adapter.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/mcp_plugin/adapter.py",
38
+ "mcp_output/mcp_plugin/main.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/mcp_plugin/main.py",
39
+ "mcp_output/requirements.txt": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/requirements.txt",
40
+ "mcp_output/README_MCP.md": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/README_MCP.md",
41
+ "mcp_output/tests_mcp/test_mcp_basic.py": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/tests_mcp/test_mcp_basic.py"
42
+ },
43
+ "adapter_mode": "import",
44
+ "endpoints": [
45
+ "MolFromSmiles",
46
+ "MolToSmiles",
47
+ "AddHs",
48
+ "RemoveHs",
49
+ "mol",
50
+ "atom",
51
+ "bond",
52
+ "CalcMolWt",
53
+ "CalcExactMolWt",
54
+ "CalcNumHBA",
55
+ "CalcNumHBD",
56
+ "MolToImage",
57
+ "MolToImageFile",
58
+ "MolToImageBytes",
59
+ "moldrawoptions",
60
+ "ClusterData",
61
+ "OnBitsFromBits",
62
+ "BitsToText"
63
+ ],
64
+ "mcp_dir": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/mcp_plugin",
65
+ "tests_dir": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/tests_mcp",
66
+ "main_entry": "start_mcp.py",
67
+ "readme_path": "/export/project/shiweijie/ghh/LLM_MCP_RAG/MCP-agent-github-repo-output/workspace/rdkit/mcp_output/README_MCP.md",
68
+ "requirements": [
69
+ "fastmcp>=0.1.0",
70
+ "pydantic>=2.0.0"
71
+ ]
72
+ },
73
+ "fastmcp_installed": false
74
+ }
rdkit/mcp_output/mcp_plugin/__init__.py ADDED
File without changes
rdkit/mcp_output/mcp_plugin/__pycache__/adapter.cpython-310.pyc ADDED
Binary file (7.48 kB). View file
 
rdkit/mcp_output/mcp_plugin/__pycache__/mcp_service.cpython-310.pyc ADDED
Binary file (1.89 kB). View file
 
rdkit/mcp_output/mcp_plugin/adapter.py ADDED
@@ -0,0 +1,249 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import os
2
+ import sys
3
+
4
+ # Path settings
5
+ source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
6
+ sys.path.insert(0, source_path)
7
+
8
+ # Import statements
9
+ try:
10
+ from rdkit.Chem import MolFromSmiles, MolToSmiles, AddHs, MolFromMolFile, MolToMolFile
11
+ from rdkit.Chem import SDMolSupplier, SubstructMatch, Compute2DCoords, EmbedMolecule
12
+ from rdkit.Chem import ChemicalReaction, ReactionFromSmarts
13
+ from rdkit.Chem.AllChem import GetMorganFingerprintAsBitVect
14
+ from rdkit.Chem.Draw import MolToImage
15
+ import numpy as np
16
+ import pandas as pd
17
+ import matplotlib.pyplot as plt
18
+ except ImportError as e:
19
+ print("Error: Failed to import RDKit modules. Ensure RDKit is installed and accessible.")
20
+ print(f"Details: {e}")
21
+ fallback_mode = True
22
+ else:
23
+ fallback_mode = False
24
+
25
+
26
+ class Adapter:
27
+ """
28
+ Adapter class for RDKit functionalities.
29
+ Provides methods to interact with RDKit's core features, including molecule manipulation,
30
+ substructure searching, fingerprint generation, and visualization.
31
+ """
32
+
33
+ def __init__(self):
34
+ """
35
+ Initialize the Adapter class.
36
+ Sets the mode to 'import' if RDKit modules are successfully imported, otherwise 'fallback'.
37
+ """
38
+ self.mode = "import" if not fallback_mode else "fallback"
39
+
40
+ # -------------------------------------------------------------------------
41
+ # Molecule Manipulation Methods
42
+ # -------------------------------------------------------------------------
43
+
44
+ def create_molecule_from_smiles(self, smiles):
45
+ """
46
+ Create a molecule object from a SMILES string.
47
+
48
+ Parameters:
49
+ smiles (str): The SMILES string representing the molecule.
50
+
51
+ Returns:
52
+ dict: A dictionary containing the status and the molecule object or error message.
53
+ """
54
+ try:
55
+ if self.mode == "fallback":
56
+ return {"status": "error", "message": "RDKit is not available in fallback mode."}
57
+ mol = MolFromSmiles(smiles)
58
+ if mol is None:
59
+ return {"status": "error", "message": "Invalid SMILES string."}
60
+ return {"status": "success", "molecule": mol}
61
+ except Exception as e:
62
+ return {"status": "error", "message": f"Failed to create molecule: {e}"}
63
+
64
+ def convert_molecule_to_smiles(self, mol):
65
+ """
66
+ Convert a molecule object to a SMILES string.
67
+
68
+ Parameters:
69
+ mol: The molecule object.
70
+
71
+ Returns:
72
+ dict: A dictionary containing the status and the SMILES string or error message.
73
+ """
74
+ try:
75
+ if self.mode == "fallback":
76
+ return {"status": "error", "message": "RDKit is not available in fallback mode."}
77
+ smiles = MolToSmiles(mol)
78
+ return {"status": "success", "smiles": smiles}
79
+ except Exception as e:
80
+ return {"status": "error", "message": f"Failed to convert molecule to SMILES: {e}"}
81
+
82
+ def add_hydrogens(self, mol):
83
+ """
84
+ Add hydrogens to a molecule.
85
+
86
+ Parameters:
87
+ mol: The molecule object.
88
+
89
+ Returns:
90
+ dict: A dictionary containing the status and the modified molecule or error message.
91
+ """
92
+ try:
93
+ if self.mode == "fallback":
94
+ return {"status": "error", "message": "RDKit is not available in fallback mode."}
95
+ mol_with_h = AddHs(mol)
96
+ return {"status": "success", "molecule": mol_with_h}
97
+ except Exception as e:
98
+ return {"status": "error", "message": f"Failed to add hydrogens: {e}"}
99
+
100
+ # -------------------------------------------------------------------------
101
+ # File Handling Methods
102
+ # -------------------------------------------------------------------------
103
+
104
+ def read_molecule_from_file(self, file_path):
105
+ """
106
+ Read a molecule from a file.
107
+
108
+ Parameters:
109
+ file_path (str): Path to the molecule file.
110
+
111
+ Returns:
112
+ dict: A dictionary containing the status and the molecule object or error message.
113
+ """
114
+ try:
115
+ if self.mode == "fallback":
116
+ return {"status": "error", "message": "RDKit is not available in fallback mode."}
117
+ mol = MolFromMolFile(file_path)
118
+ if mol is None:
119
+ return {"status": "error", "message": "Failed to read molecule from file."}
120
+ return {"status": "success", "molecule": mol}
121
+ except Exception as e:
122
+ return {"status": "error", "message": f"Failed to read molecule from file: {e}"}
123
+
124
+ def write_molecule_to_file(self, mol, file_path):
125
+ """
126
+ Write a molecule to a file.
127
+
128
+ Parameters:
129
+ mol: The molecule object.
130
+ file_path (str): Path to save the molecule file.
131
+
132
+ Returns:
133
+ dict: A dictionary containing the status and a success message or error message.
134
+ """
135
+ try:
136
+ if self.mode == "fallback":
137
+ return {"status": "error", "message": "RDKit is not available in fallback mode."}
138
+ MolToMolFile(mol, file_path)
139
+ return {"status": "success", "message": "Molecule written to file successfully."}
140
+ except Exception as e:
141
+ return {"status": "error", "message": f"Failed to write molecule to file: {e}"}
142
+
143
+ # -------------------------------------------------------------------------
144
+ # Substructure Searching Methods
145
+ # -------------------------------------------------------------------------
146
+
147
+ def substructure_search(self, target_mol, query_smarts):
148
+ """
149
+ Perform a substructure search.
150
+
151
+ Parameters:
152
+ target_mol: The target molecule object.
153
+ query_smarts (str): The SMARTS pattern for the query.
154
+
155
+ Returns:
156
+ dict: A dictionary containing the status and match results or error message.
157
+ """
158
+ try:
159
+ if self.mode == "fallback":
160
+ return {"status": "error", "message": "RDKit is not available in fallback mode."}
161
+ query = MolFromSmiles(query_smarts)
162
+ if query is None:
163
+ return {"status": "error", "message": "Invalid SMARTS pattern."}
164
+ matches = SubstructMatch(target_mol, query)
165
+ return {"status": "success", "matches": matches}
166
+ except Exception as e:
167
+ return {"status": "error", "message": f"Failed to perform substructure search: {e}"}
168
+
169
+ # -------------------------------------------------------------------------
170
+ # Fingerprint Generation Methods
171
+ # -------------------------------------------------------------------------
172
+
173
+ def generate_morgan_fingerprint(self, mol, radius=2):
174
+ """
175
+ Generate a Morgan fingerprint for a molecule.
176
+
177
+ Parameters:
178
+ mol: The molecule object.
179
+ radius (int): The radius for the fingerprint.
180
+
181
+ Returns:
182
+ dict: A dictionary containing the status and the fingerprint or error message.
183
+ """
184
+ try:
185
+ if self.mode == "fallback":
186
+ return {"status": "error", "message": "RDKit is not available in fallback mode."}
187
+ fingerprint = GetMorganFingerprintAsBitVect(mol, radius)
188
+ return {"status": "success", "fingerprint": fingerprint}
189
+ except Exception as e:
190
+ return {"status": "error", "message": f"Failed to generate Morgan fingerprint: {e}"}
191
+
192
+ # -------------------------------------------------------------------------
193
+ # Visualization Methods
194
+ # -------------------------------------------------------------------------
195
+
196
+ def draw_molecule(self, mol):
197
+ """
198
+ Draw a molecule and return the image.
199
+
200
+ Parameters:
201
+ mol: The molecule object.
202
+
203
+ Returns:
204
+ dict: A dictionary containing the status and the image or error message.
205
+ """
206
+ try:
207
+ if self.mode == "fallback":
208
+ return {"status": "error", "message": "RDKit is not available in fallback mode."}
209
+ img = MolToImage(mol)
210
+ return {"status": "success", "image": img}
211
+ except Exception as e:
212
+ return {"status": "error", "message": f"Failed to draw molecule: {e}"}
213
+
214
+ # -------------------------------------------------------------------------
215
+ # Chemical Reaction Methods
216
+ # -------------------------------------------------------------------------
217
+
218
+ def create_reaction(self, smarts):
219
+ """
220
+ Create a chemical reaction from a SMARTS string.
221
+
222
+ Parameters:
223
+ smarts (str): The SMARTS string representing the reaction.
224
+
225
+ Returns:
226
+ dict: A dictionary containing the status and the reaction object or error message.
227
+ """
228
+ try:
229
+ if self.mode == "fallback":
230
+ return {"status": "error", "message": "RDKit is not available in fallback mode."}
231
+ reaction = ReactionFromSmarts(smarts)
232
+ if reaction is None:
233
+ return {"status": "error", "message": "Invalid SMARTS string for reaction."}
234
+ return {"status": "success", "reaction": reaction}
235
+ except Exception as e:
236
+ return {"status": "error", "message": f"Failed to create reaction: {e}"}
237
+
238
+ # -------------------------------------------------------------------------
239
+ # Utility Methods
240
+ # -------------------------------------------------------------------------
241
+
242
+ def get_mode(self):
243
+ """
244
+ Get the current mode of the adapter.
245
+
246
+ Returns:
247
+ dict: A dictionary containing the status and the current mode.
248
+ """
249
+ return {"status": "success", "mode": self.mode}
rdkit/mcp_output/mcp_plugin/main.py ADDED
@@ -0,0 +1,13 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ MCP Service Auto-Wrapper - Auto-generated
3
+ """
4
+ from mcp_service import create_app
5
+
6
+ def main():
7
+ """Main entry point"""
8
+ app = create_app()
9
+ return app
10
+
11
+ if __name__ == "__main__":
12
+ app = main()
13
+ app.run()
rdkit/mcp_output/mcp_plugin/mcp_service.py ADDED
@@ -0,0 +1,54 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import os
2
+ import sys
3
+
4
+ source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
5
+ sys.path.insert(0, source_path)
6
+
7
+ from fastmcp import FastMCP
8
+ from rdkit.Chem import FeatFinderCLI
9
+ from Scripts.run_python_tests import run_python_tests
10
+
11
+ mcp = FastMCP("rdkit_service")
12
+
13
+ @mcp.tool(name="find_features", description="Find chemical features in molecules.")
14
+ def find_features(input_file: str) -> dict:
15
+ """
16
+ Finds chemical features in molecules using RDKit's FeatFinderCLI.
17
+
18
+ Parameters:
19
+ input_file (str): Path to the input file containing molecular data.
20
+
21
+ Returns:
22
+ dict: A dictionary containing success, result, or error fields.
23
+ """
24
+ try:
25
+ result = FeatFinderCLI.main(input_file)
26
+ return {"success": True, "result": result, "error": None}
27
+ except Exception as e:
28
+ return {"success": False, "result": None, "error": str(e)}
29
+
30
+ @mcp.tool(name="run_tests", description="Run Python tests in the RDKit repository.")
31
+ def run_tests(test_directory: str) -> dict:
32
+ """
33
+ Runs Python tests in the RDKit repository.
34
+
35
+ Parameters:
36
+ test_directory (str): Path to the directory containing test files.
37
+
38
+ Returns:
39
+ dict: A dictionary containing success, result, or error fields.
40
+ """
41
+ try:
42
+ result = run_python_tests.main(test_directory)
43
+ return {"success": True, "result": result, "error": None}
44
+ except Exception as e:
45
+ return {"success": False, "result": None, "error": str(e)}
46
+
47
+ def create_app() -> FastMCP:
48
+ """
49
+ Creates and returns the FastMCP application instance.
50
+
51
+ Returns:
52
+ FastMCP: The FastMCP application instance.
53
+ """
54
+ return mcp
rdkit/mcp_output/requirements.txt ADDED
@@ -0,0 +1,11 @@
 
 
 
 
 
 
 
 
 
 
 
 
1
+ fastmcp>=0.1.0
2
+ pydantic>=2.0.0
3
+ numpy
4
+ pandas
5
+ matplotlib
6
+ scipy
7
+
8
+ # Optional Dependencies
9
+ # pillow
10
+ # pytest
11
+ # jupyter
rdkit/mcp_output/start_mcp.py ADDED
@@ -0,0 +1,34 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+
2
+ """
3
+ MCP Service Startup Entry
4
+ """
5
+ import sys
6
+ import os
7
+
8
+ project_root = os.path.dirname(os.path.abspath(__file__))
9
+ mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
10
+ if mcp_plugin_dir not in sys.path:
11
+ sys.path.insert(0, mcp_plugin_dir)
12
+
13
+ # Set path to source directory
14
+ source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
15
+ sys.path.insert(0, source_path)
16
+
17
+ from mcp_service import create_app
18
+
19
+ def main():
20
+ """Start FastMCP service"""
21
+ app = create_app()
22
+ # Use environment variable to configure port, default 8000
23
+ port = int(os.environ.get("MCP_PORT", "8000"))
24
+
25
+ # Choose transport mode based on environment variable
26
+ transport = os.environ.get("MCP_TRANSPORT", "stdio")
27
+ if transport == "http":
28
+ app.run(transport="http", host="0.0.0.0", port=port)
29
+ else:
30
+ # Default to STDIO mode
31
+ app.run()
32
+
33
+ if __name__ == "__main__":
34
+ main()
rdkit/mcp_output/tests_mcp/test_mcp_basic.py ADDED
@@ -0,0 +1,49 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ MCP Service Basic Test
3
+ """
4
+ import sys
5
+ import os
6
+
7
+ project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
8
+ mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
9
+ if mcp_plugin_dir not in sys.path:
10
+ sys.path.insert(0, mcp_plugin_dir)
11
+
12
+ source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
13
+ sys.path.insert(0, source_path)
14
+
15
+ def test_import_mcp_service():
16
+ """Test if MCP service can be imported normally"""
17
+ try:
18
+ from mcp_service import create_app
19
+ app = create_app()
20
+ assert app is not None
21
+ print("MCP service imported successfully")
22
+ return True
23
+ except Exception as e:
24
+ print("MCP service import failed: " + str(e))
25
+ return False
26
+
27
+ def test_adapter_init():
28
+ """Test if adapter can be initialized normally"""
29
+ try:
30
+ from adapter import Adapter
31
+ adapter = Adapter()
32
+ assert adapter is not None
33
+ print("Adapter initialized successfully")
34
+ return True
35
+ except Exception as e:
36
+ print("Adapter initialization failed: " + str(e))
37
+ return False
38
+
39
+ if __name__ == "__main__":
40
+ print("Running MCP service basic test...")
41
+ test1 = test_import_mcp_service()
42
+ test2 = test_adapter_init()
43
+
44
+ if test1 and test2:
45
+ print("All basic tests passed")
46
+ sys.exit(0)
47
+ else:
48
+ print("Some tests failed")
49
+ sys.exit(1)
rdkit/mcp_output/tests_smoke/test_smoke.py ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import importlib, sys
2
+ import os
3
+
4
+ # Add current directory to Python path
5
+ sys.path.insert(0, os.getcwd())
6
+
7
+ source_dir = os.path.join(os.getcwd(), "source")
8
+ if os.path.exists(source_dir):
9
+ sys.path.insert(0, source_dir)
10
+
11
+
12
+ try:
13
+ importlib.import_module("rdkit")
14
+ print("OK - Successfully imported rdkit")
15
+ except ImportError as e:
16
+ print(f"Failed to import rdkit: {e}")
17
+ fallback_packages = []
18
+
19
+ fallback_packages = ['rdkit']
20
+
21
+ for pkg in fallback_packages:
22
+ try:
23
+ importlib.import_module(pkg)
24
+ print(f"OK - Successfully imported {pkg}")
25
+ break
26
+ except ImportError:
27
+ continue
28
+ else:
29
+ print("All import attempts failed")