dynverse / dynmethods

A collection of 50+ trajectory inference methods within a common interface 📥📤

https://dynverse.org

Other

118 stars 26 forks source link

Update all methods for the new dynwrap #149

Closed rcannood closed 5 years ago

rcannood commented 5 years ago

overview

[x] angle
[x] calista
[x] cellrouter
[x] celltrails
[x] celltree_gibbs
[x] celltree_maptpx
[x] celltree_vem
[x] comp1
[x] dpt
[x] elpicycle
[x] elpigraph
[x] elpilinear
[x] embeddr
[x] error
[x] fateid
[x] forks
[x] gng
[x] gpfates
[x] grandprix
[x] identity
[x] matcher
[x] merlot
[x] mfa
[x] monocle_ddrtree
[x] monocle_ica
[x] mpath
[x] mst
[x] ouija
[x] ouijaflow
[x] paga
[x] paga_tree
[x] pcreode
[x] periodpc
[x] phenopath
[x] projected_dpt
[x] projected_monocle
[x] projected_paga
[x] projected_slingshot
[x] projected_tscan
[x] pseudogp
[x] raceid_stemid
[x] random
[x] recat
[x] scimitar
[x] scorpius
[x] scoup
[x] scuba
[x] shuffle
[x] sincell
[x] slice
[x] slicer
[x] slingshot
[x] stemnet
[x] topslam
[x] tscan
[x] urd
[x] wanderlust
[x] waterfall
[x] wishbone

rcannood commented 5 years ago

angle

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_angle .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_angle/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_angle/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_angle --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_angle --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

calista

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_calista .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_calista/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_calista/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_calista --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_calista --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

cellrouter

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_cellrouter .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_cellrouter/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_cellrouter/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_cellrouter --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_cellrouter --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

celltrails

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_celltrails .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_celltrails/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_celltrails/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_celltrails --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_celltrails --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

celltree_gibbs

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_celltree_gibbs .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_celltree_gibbs/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_celltree_gibbs/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_celltree_gibbs --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_celltree_gibbs --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

celltree_maptpx

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_celltree_maptpx .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_celltree_maptpx/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_celltree_maptpx/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_celltree_maptpx --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_celltree_maptpx --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

celltree_vem

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_celltree_vem .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_celltree_vem/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_celltree_vem/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_celltree_vem --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_celltree_vem --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

comp1

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_comp1 .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_comp1/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_comp1/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_comp1 --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_comp1 --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

dpt

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_dpt .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_dpt/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_dpt/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_dpt --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_dpt --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

elpicycle

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_elpicycle .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_elpicycle/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_elpicycle/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_elpicycle --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_elpicycle --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

elpigraph

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_elpigraph .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_elpigraph/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_elpigraph/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_elpigraph --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_elpigraph --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

elpilinear

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_elpilinear .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_elpilinear/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_elpilinear/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_elpilinear --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_elpilinear --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

embeddr

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_embeddr .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_embeddr/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_embeddr/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_embeddr --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_embeddr --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

error

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_error .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_error/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_error/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_error --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_error --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

fateid

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_fateid .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_fateid/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_fateid/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_fateid --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_fateid --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

forks

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_forks .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_forks/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_forks/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_forks --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_forks --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

gng

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_gng .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_gng/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_gng/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_gng --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_gng --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

gpfates

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_gpfates .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_gpfates/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_gpfates/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_gpfates --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_gpfates --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

grandprix

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_grandprix .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_grandprix/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_grandprix/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_grandprix --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_grandprix --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

identity

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_identity .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_identity/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_identity/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_identity --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_identity --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

matcher

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_matcher .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_matcher/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_matcher/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_matcher --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_matcher --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

merlot

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_merlot .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_merlot/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_merlot/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_merlot --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_merlot --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

mfa

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_mfa .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_mfa/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_mfa/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_mfa --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_mfa --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

monocle_ddrtree

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_monocle_ddrtree .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_monocle_ddrtree/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_monocle_ddrtree/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_monocle_ddrtree --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_monocle_ddrtree --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

monocle_ica

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_monocle_ica .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_monocle_ica/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_monocle_ica/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_monocle_ica --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_monocle_ica --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

mpath

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_mpath .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_mpath/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_mpath/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_mpath --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_mpath --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

mst

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_mst .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_mst/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_mst/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_mst --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_mst --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

ouija

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_ouija .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_ouija/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_ouija/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_ouija --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_ouija --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

ouijaflow

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_ouijaflow .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_ouijaflow/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_ouijaflow/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_ouijaflow --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_ouijaflow --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

paga

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_paga .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_paga/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_paga/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_paga --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_paga --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

paga_tree

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_paga_tree .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_paga_tree/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_paga_tree/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_paga_tree --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_paga_tree --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

pcreode

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_pcreode .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_pcreode/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_pcreode/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_pcreode --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_pcreode --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

periodpc

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_periodpc .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_periodpc/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_periodpc/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_periodpc --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_periodpc --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

phenopath

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_phenopath .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_phenopath/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_phenopath/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_phenopath --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_phenopath --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

projected_dpt

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_projected_dpt .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_projected_dpt/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_projected_dpt/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_projected_dpt --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_projected_dpt --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

projected_monocle

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_projected_monocle .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_projected_monocle/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_projected_monocle/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_projected_monocle --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_projected_monocle --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

projected_paga

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_projected_paga .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_projected_paga/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_projected_paga/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_projected_paga --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_projected_paga --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

projected_slingshot

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_projected_slingshot .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_projected_slingshot/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_projected_slingshot/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_projected_slingshot --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_projected_slingshot --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

projected_tscan

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_projected_tscan .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_projected_tscan/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_projected_tscan/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_projected_tscan --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_projected_tscan --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

pseudogp

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_pseudogp .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_pseudogp/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_pseudogp/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_pseudogp --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_pseudogp --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

raceid_stemid

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_raceid_stemid .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_raceid_stemid/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_raceid_stemid/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_raceid_stemid --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_raceid_stemid --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

random

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_random .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_random/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_random/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_random --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_random --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[x] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

recat

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_recat .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_recat/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_recat/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_recat --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_recat --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

scimitar

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_scimitar .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_scimitar/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_scimitar/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_scimitar --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_scimitar --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

scorpius

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_scorpius .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_scorpius/builds/edit
- Remove Singularity file
[x] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_scorpius/definition.yml")
[x] Write new run.R/py and chmod +x run.R
[x] Write new example.R (see ti_angle example) and chmod +x
[x] Rebuild!

[x] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_scorpius --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_scorpius --dataset /mnt/example.h5 --output /mnt/output.h5

[x] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

scoup

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_scoup .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_scoup/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_scoup/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_scoup --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_scoup --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

scuba

[x] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_scuba .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_scuba/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_scuba/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_scuba --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_scuba --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

shuffle

All done - waiting for new dynwrap_containers before pushing

rcannood commented 5 years ago

sincell

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_sincell .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_sincell/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_sincell/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_sincell --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_sincell --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully

rcannood commented 5 years ago

slice

[ ] Write new Dockerfile:
- Depend on dynwrapr/dynwrappy
- Remove version label
- Use COPY instead of ADD
- Update ENTRYPOINT
- Create example h5:
```
Rscript ./example.R /tmp/example.h5
```
- Build docker container
```
docker build -t dynverse/ti_slice .
```
- Turn off docker automated builds: go to https://cloud.docker.com/u/dynverse/repository/docker/dynverse/ti_slice/builds/edit
- Remove Singularity file
[ ] Write new definition.yml and create version file with version 1.0.0
- Test with dynwrap::create_ti_method_definition("ti_slice/definition.yml")
[ ] Write new run.R/py and chmod +x run.R
[ ] Write new example.R (see ti_angle example) and chmod +x
[ ] Rebuild!

[ ] Verify that method works:

docker run -v /tmp:/mnt dynverse/ti_slice --dataset /mnt/example.h5 --output /mnt/output.h5
dyncli::read_h5("/tmp/output.h5") %>% dynplot::plot_dimred()
sudo rm /tmp/example.h5 /tmp/output.h5

If it doesn't…:

docker run -it -v /tmp:/mnt --entrypoint R dynverse/ti_slice --dataset /mnt/example.h5 --output /mnt/output.h5

[ ] Run travis_enc_all
[ ] Create pull request and merge once travis has finished successfully