I tried something like this already, for example this does what I want:


#+BEGIN_SRC ipython :tangle (if (eq tangle-tag 'one) "one.py" "no")
print('hello')
#+END_SRC

#+BEGIN_SRC text :tangle (if (eq tangle-tag 'one) "one.dat" "no")
print('hello')
#+END_SRC

#+BEGIN_SRC ipython :tangle (if (eq tangle-tag 'two) "two.py" "no")
print('hello2')
#+END_SRC

#+BEGIN_SRC makefile :tangle (if (eq tangle-tag 'two) "Makefile" "no")
build:
python two.py
#+END_SRC

Now only tangle things with a 'two
#+BEGIN_SRC emacs-lisp
(let ((tangle-tag 'two))
  (org-babel-tangle))
#+END_SRC

I didn't see a way to avoid having an intermediate variable to specify what
to tangle. This should have a check on if tangle-tag is bound to avoid an
error with regular tangle. Maybe it could be cleaned up by a function as
you describe, e.g. (selective-tangle 'two filename).

Another way I tried is this:

** example two

#+BEGIN_SRC ipython :tangle "one.py" :one
print('hello')
#+END_SRC

#+BEGIN_SRC text :tangle "one.dat" :one
print('hello')
#+END_SRC

#+BEGIN_SRC ipython :tangle "two.py" :two
print('hello2')
#+END_SRC

#+BEGIN_SRC makefile :tangle "Makefile" :two
build:
python two.py
#+END_SRC


#+BEGIN_SRC emacs-lisp
(org-babel-map-src-blocks (buffer-file-name)
  (let ((ha (read (format "(%s)" (substring-no-properties header-args)))))
    (when (memq :two ha)
      (org-babel-tangle '(4)))))
#+END_SRC

#+RESULTS:
: 5235

I don't have strong feelings yet which way is better.

John

-----------------------------------
Professor John Kitchin
Doherty Hall A207F
Department of Chemical Engineering
Carnegie Mellon University
Pittsburgh, PA 15213
412-268-7803
@johnkitchin
http://kitchingroup.cheme.cmu.edu



On Thu, Nov 29, 2018 at 11:44 AM Berry, Charles <ccberry@ucsd.edu> wrote:

>
>
> > On Nov 29, 2018, at 5:10 AM, John Kitchin <jkitchin@andrew.cmu.edu>
> wrote:
> >
> > Are there any ways to selectively tangle blocks?
> >
> > By that I mean suppose there are a dozen src blocks in a file, but I
> want to selectively tangle only a few of them, selecting them by a tag, for
> example, or some other property. These might have mixed languages, e.g. a
> config files, a python script, and a makefile.
> >
> > The use case here is I have an org document that I use to document a
> simulation. The simulation has several config files, and a makefile, and
> there is a python script that does analysis. I like to put all of these in
> src blocks and then use a sh block to run the actual simulation command. I
> usually put a :var a=(org-babel-tangle) header in the sh block, which makes
> sure the files are tangled, and then runs the shell commands. But this
> tangles all the files in the buffer, which is usually not what I want
> (there are sometimes multiple simulations described in one file).  The
> blocks are not always in one subtree, so it isn't a matter of just
> narrowing, and they are mixed languages (text, make, python, etc.) and
> target files so I can't just target one file.
> >
> > The only mechanism for this i have come up with is to use
> org-babel-map-src-blocks to run a check on each block to see if it matches
> my tangle criteria and then run (org-babel-tangle t) on that block. This
> seems to work fine, but I thought I would check if anyone else has a better
> solution.
> >
> >
>
> Use the :tangle header arg with your check function and its args:
>
>         :tangle (my-tangle-selector ...)
>
> HTH,
>
> Chuck
>
>
>
>