Merge pull request #2339 from nd-02110114/remove-devtools

Developer Notes / Tools

=======================

How to do a release

-------------------

### Pre-release

- Create an issue about cutting the release.

### Release

- Tag current master with new release version

- Look at github issues merged since last release

- Bump Dockerfile Version

- Update README with new version string

- Update Website install commands

### Post-release

- Update the docker images

```bash

sudo docker build -f Dockerfile .

sudo docker image list

# smoke test everything

nvidia-docker run -i -t \<IMAGE ID\>

python scripts/detect_devices.py // verify gpu is enabled

cd examples; python benchmark.py -d tox21

sudo docker tag \<IMAGE ID\> deepchemio/deepchem:latest

sudo docker push deepchemio/deepchem:latest

sudo docker tag \<IMAGE ID\> deepchemio/deepchem:<version>

sudo docker push deepchemio/deepchem:<version>

```

- Update conda installs

  - edit version in devtools/conda-recipes/deepchem/meta.yml

  - update requirements to be inline with scripts/install_deepchem_conda.sh

  - set deepchem anaconda org token

  - bash devtools/jenkins/conda_build.sh

- Post on Gitter

$PYTHON setup.py install

python:

- 3.5

- 3.6

- 3.7

package:

  name: {{ environ.get('package_name', 'deepchem') }}

  version: "2.3.0"

source:

    git_url: https://github.com/deepchem/deepchem.git

    git_tag: 2.3.0

build:

  number: 0

  skip: True  # [win]

requirements:

  build:

    - python {{ python }}

    - setuptools

    - pbr

    - numpy

  run:

    - python {{ python }}

    - pdbfixer

    - mdtraj

    - joblib

    - scikit-learn

    - networkx

    - xgboost

    - pillow

    - pandas

    - {{ environ.get('tensorflow_enabled','tensorflow') }} ==1.14.0

    - zlib

    - requests

    - simdna

    - jupyter

    - rdkit

about:

  home: https://github.com/deepchem/deepchem

  license: MIT

  summary: 'Deep-learning models for Drug Discovery and Quantum Chemistry '

  description: |

    DeepChem aims to provide a high quality open-source toolchain that

    democratizes the use of deep-learning in drug discovery, materials

    science, quantum chemistry, and biology.

  doc_url: https://deepchem.io/

  dev_url: https:/github.com/deepchem/deepchem

import unittest

class TestDeepchemBuild(unittest.TestCase):

  def setUp(self):

    pass

  def tearDown(self):

    import deepchem

    import os

    import shutil

    data_dir = deepchem.utils.data_utils.get_data_dir()

    bace_dir = os.path.join(data_dir, "bace_c")

    delaney_dir = os.path.join(data_dir, "delaney")

    try:

      shutil.rmtree(bace_dir, ignore_errors=True)

    except:

      pass

  def test_dc_import(self):

    import deepchem

    print(deepchem.__version__)

  def test_rdkit_import(self):

    import rdkit

    print(rdkit.__version__)

  def test_numpy_import(self):

    import numpy as np

    print(np.__version__)

  def test_pandas_import(self):

    import pandas as pd

    print(pd.__version__)

  def get_dataset(self,

                  mode='classification',

                  featurizer='GraphConv',

                  num_tasks=2):

    from deepchem.molnet import load_bace_classification, load_delaney

    import numpy as np

    import deepchem as dc

    from deepchem.data import NumpyDataset

    data_points = 10

    if mode == 'classification':

      tasks, all_dataset, transformers = load_bace_classification(featurizer)

    else:

      tasks, all_dataset, transformers = load_delaney(featurizer)

    train, valid, test = all_dataset

    for i in range(1, num_tasks):

      tasks.append("random_task")

    w = np.ones(shape=(data_points, len(tasks)))

    if mode == 'classification':

      y = np.random.randint(0, 2, size=(data_points, len(tasks)))

      metric = dc.metrics.Metric(

          dc.metrics.roc_auc_score, np.mean, mode="classification")

    else:

      y = np.random.normal(size=(data_points, len(tasks)))

      metric = dc.metrics.Metric(

          dc.metrics.mean_absolute_error, mode="regression")

    ds = NumpyDataset(train.X[:data_points], y, w, train.ids[:data_points])

    return tasks, ds, transformers, metric

  def test_graph_conv_model(self):

    from deepchem.models import GraphConvModel, TensorGraph

    import numpy as np

    tasks, dataset, transformers, metric = self.get_dataset(

        'classification', 'GraphConv')

    batch_size = 50

    model = GraphConvModel(

        len(tasks), batch_size=batch_size, mode='classification')

    model.fit(dataset, nb_epoch=10)

    scores = model.evaluate(dataset, [metric], transformers)

    assert scores['mean-roc_auc_score'] >= 0.9

if __name__ == '__main__':

  unittest.main()