Rename metadata to targets_metadata

Author: basiekjusz

README.md

@@ -7,42 +7,52 @@
 ```
 pip install git+https://github.com/molecule-one/m1wrapper-python
 ```
+
 ### Initialization:
+
 ```py
 from m1wrapper import MoleculeOneWrapper
 m1wrapper = MoleculeOneWrapper(api_token, 'https://app.molecule.one')
 ```
-- *api_token*: API token you'll need to authorize in our system. You can
+
+- _api_token_: API token you'll need to authorize in our system. You can
   generate yours at https://app.molecule.one/dashboard/user/api-tokens
-- *api_base_url* (optional): URI of the batch scoring service. Defaults to Molecule One's public
+- _api_base_url_ (optional): URI of the batch scoring service. Defaults to Molecule One's public
   server, but you will need to provide custom value if you're using a dedicated solution.
 
 ### Getting a list of batch scoring requests:
+
 ```py
 searches = m1wrapper.list_batch_searches()
 ```
 
 ### Running new batch scoring request:
+
 ```py
 search = m1wrapper.run_batch_search(
     targets=['cc', 'O=C(Nc1cc(Nc2nc(-c3cnccc3)ccn2)c(cc1)C)c3ccc(cc3)CN3CCN(CC3)C'],
     parameters={'model': 'gat'}
 )
 ```
-- *targets*: list of target compounds in SMILES format
-- *parameters* (optional): additional configuration for your batch
+
+- _targets_: list of target compounds in SMILES format
+- _parameters_ (optional): additional configuration for your batch
   scoring request. See [Batch Scoring API](https://github.com/molecule-one/api/blob/master/api-v2.md) for more information.
-- *detail_level* (optional): [detail level of the batch request](#batch-scoring-detail-level)
-- *priority* (optional): [priority of the batch request](#batch-scoring-priorities)
-- *invalid_target_strategy* (optional): if set to `InvalidTargetStrategy.PASS`, targets that cannot be canonized by our SMILES parser won't cause the whole batch request to be rejected. Defaults to `InvalidTargetStrategy.REJECT`.
-- *starting_materials* (optional): list of available compounds in SMILES format
-- *name* (optional): name of your batch request
+- _detail_level_ (optional): [detail level of the batch request](#batch-scoring-detail-level)
+- _priority_ (optional): [priority of the batch request](#batch-scoring-priorities)
+- _invalid_target_strategy_ (optional): if set to `InvalidTargetStrategy.PASS`, targets that cannot be canonized by our SMILES parser won't cause the whole batch request to be rejected. Defaults to `InvalidTargetStrategy.REJECT`.
+- _starting_materials_ (optional): list of available compounds in SMILES format
+- _name_ (optional): name of your batch request
 
 ### Batch scoring detail level
+
 Detail level determines how much information about each target synthesis you'll get. We define it as a `DetailLevel` enum with two variants:
+
 - `DetailLevel.SCORE` (default) - useful when you're not interested in full synthesis json/UI preview, but only numerical values
 - `DetailLevel.SYNTHESIS` - when you're also interested in reactions and compounds leading to the target product
+
 #### Example:
+
 ```py
 from m1wrapper import MoleculeOneWrapper, DetailLevel
 m1wrapper = MoleculeOneWrapper(api_token, 'https://app.molecule.one')
@@ -54,15 +64,18 @@ search = m1wrapper.run_batch_search(
 ```
 
 ### Batch scoring priorities
+
 Priorities are defined as integers in a range of 1 to 10. Requests with higher priority will be processed before those with lower priority.
 For convenience, we also define a `Priority` enum with the following variants:
+
 - `Priority.LOWEST` (1)
 - `Priority.LOW` (3)
 - `Priority.NORMAL` (5, default)
 - `Priority.HIGH` (8)
 - `Priority.HIGHEST` (10)
 
 #### Example:
+
 ```py
 from m1wrapper import MoleculeOneWrapper, Priority
 m1wrapper = MoleculeOneWrapper(api_token, 'https://app.molecule.one')
@@ -73,51 +86,61 @@ search = m1wrapper.run_batch_search(
 )
 ```
 
-### Batch scoring request with compound metadata
+### Batch scoring request with targets metadata
+
 `run_search_with_metadata(targets_with_metadata, parameters, detail_level, priority, invalid_target_strategy, starting_materials, name)`
-- *targets_with_metadata*: list of target compounds with metadata. Each target compound should be a dictionary object of shape `{ smiles: str, name: str}` where the only required field is `smiles`.
-- *parameters* (optional): additional configuration for your batch
+
+- _targets_with_metadata_: list of target compounds with metadata. Each target compound should be a dictionary object of shape `{ smiles: str, name: str}` where the only required field is `smiles`.
+- _parameters_ (optional): additional configuration for your batch
   scoring request. See [Batch Scoring API](https://github.com/molecule-one/api/blob/master/api-v2.md) for more information.
-- *detail_level* (optional): [detail level of the batch request](#batch-scoring-detail-level)
-- *priority* (optional): [priority of the batch request](#batch-scoring-priorities)
-- *invalid_target_strategy* (optional): if set to `InvalidTargetStrategy.PASS`, targets that cannot be canonized by our SMILES parser won't cause the whole batch request to be rejected. Defaults to `InvalidTargetStrategy.REJECT`.
-- *starting_materials* (optional): list of available compounds in SMILES format
-- *name* (optional): name of your batch request
+- _detail_level_ (optional): [detail level of the batch request](#batch-scoring-detail-level)
+- _priority_ (optional): [priority of the batch request](#batch-scoring-priorities)
+- _invalid_target_strategy_ (optional): if set to `InvalidTargetStrategy.PASS`, targets that cannot be canonized by our SMILES parser won't cause the whole batch request to be rejected. Defaults to `InvalidTargetStrategy.REJECT`.
+- _starting_materials_ (optional): list of available compounds in SMILES format
+- _name_ (optional): name of your batch request
 
 ```py
 run_search_with_metadata(targets_with_metadata=[{name: 'compound1', smiles: a}, {smiles: b}, {name: 'compound3', smiles: c}], priority=Priority.HIGH)
 ```
 
 ### Getting exisiting scoring request by id:
+
 ```py
 search = m1wrapper.get_batch_search(id)
 ```
 
 ### Checking if your scoring request processing is finished:
+
 ```py
 search.is_finished()
 ```
 
 ### Checking full search status:
+
 ```py
 status = search.get_status()
 ```
+
 In response, you’ll get information about your batch scoring processing progress, i.e.:
 `{"queued":92,"running":4,"finished":104,"error":0}`
 
 ### Getting partial results:
+
 Results are made available as soon as they are processed. This method
 provided a way to start working with some of your results without waiting until all targets are processed.
 This usually means implementing some kind of polling/scheduling on your side.
+
 ```py
 results = search.get_partial_results(precision=5, only=["target_smiles", "result"])
 ```
-- *precision* (optional): format the floating point scores returned by the system (certainty, result, price) to given number of significant digits.
-- *only* (optional): fetch only a subset of values. Defaults to
+
+- _precision_ (optional): format the floating point scores returned by the system (certainty, result, price) to given number of significant digits.
+- _only_ (optional): fetch only a subset of values. Defaults to
   all values.
 
 Returns JSON object of the following shape:
 Returns an object of the following shape:
+
 ```python
     [
       {
@@ -127,12 +150,15 @@ Returns an object of the following shape:
       ...
     ]
 ```
+
 #### All values:
+
 ```py
 results = search.get_partial_results(precision=5)
 ```
 
 Returns JSON object of the following shape:
+
 ```python
     [
       {
@@ -155,16 +181,19 @@ Returns JSON object of the following shape:
 See [Batch Scoring API](https://github.com/molecule-one/api/blob/master/api-v2.md) for a full explaination of returned fields.
 
 ### Getting complete results:
+
 ```py
 results = search.get_results(precision=5, only=["target_smiles", "result"])
 ```
+
 If you don't want to implement scheduling on your own, this method
 provides a simple way to wait until all targets are processed (sending periodical checks using
 `search.is_finished()`), and execute only when all results are available. It's a
 blocking operation.
 Parameters and returned JSON are the same as with `get_partial_results()`.
 
 ### Deleting your data:
+
 ```py
 m1wrapper.delete_batch_search(search.search_id)
 ```

m1wrapper/m1wrapper.py

@@ -94,13 +94,13 @@ def run_batch_search_with_metadata(
     ) -> BatchSearch:
         targets = []
         targets_with_metadata_copy = copy.deepcopy(targets_with_metadata)
-        metadata = {}
+        targets_metadata = {}
         for index, item in enumerate(targets_with_metadata_copy):
             target = item.pop('smiles', None)
             targets.append(target)
 
             if item:
-                metadata[str(index)] = item
+                targets_metadata[str(index)] = item
 
         return BatchSearch(
                 self.api_base_url,
@@ -112,7 +112,7 @@ def run_batch_search_with_metadata(
                 invalid_target_strategy=invalid_target_strategy,
                 starting_materials=starting_materials,
                 name=name,
-                metadata=metadata
+                targets_metadata=targets_metadata
             )
 
     def get_batch_search(self, search_id: str) -> BatchSearch:

m1wrapper/search.py

@@ -37,7 +37,7 @@ def __init__(
         invalid_target_strategy=None,
         starting_materials=None,
         name=None,
-        metadata=None,
+        targets_metadata=None,
     ):
         self.search_id = search_id
         self.base_url = base_url
@@ -52,11 +52,11 @@ def __init__(
                     invalid_target_strategy=invalid_target_strategy,
                     starting_materials=starting_materials,
                     name=name,
-                    metadata=metadata
+                    targets_metadata=targets_metadata
             )
             self.search_id = new_search['id']
 
-    def __prepare_payload(self, targets, parameters, detail_level, priority, invalid_target_strategy, starting_materials, name, metadata) -> dict:
+    def __prepare_payload(self, targets, parameters, detail_level, priority, invalid_target_strategy, starting_materials, name, targets_metadata) -> dict:
         payload = {
             'targets': targets,
             'parameters': parameters or {},
@@ -68,8 +68,8 @@ def __prepare_payload(self, targets, parameters, detail_level, priority, invalid
             payload["starting_materials"] = starting_materials
         if name is not None:
             payload["name"] = name
-        if metadata is not None:
-            payload['metadata'] = metadata
+        if targets_metadata is not None:
+            payload['targets_metadata'] = targets_metadata
 
         return payload
 
@@ -87,8 +87,8 @@ def __prepare_http(self):
         http.mount("http://", adapter)
         return http
 
-    def __run(self, targets, parameters, detail_level, priority, invalid_target_strategy, starting_materials, name, metadata):
-        payload = self.__prepare_payload(targets, parameters, detail_level, priority, invalid_target_strategy, starting_materials, name, metadata)
+    def __run(self, targets, parameters, detail_level, priority, invalid_target_strategy, starting_materials, name, targets_metadata):
+        payload = self.__prepare_payload(targets, parameters, detail_level, priority, invalid_target_strategy, starting_materials, name, targets_metadata)
         response = self.http.post(
             urljoin(self.base_url, api_search_endpoint),
             data=json.dumps(payload),