It is usually better to have a module or class convert from another format to the format it understands.

While one can argue that all getters and setters are evil, it is clear that *setters are more evil and problematic*.  Setters might 

 1. cause concurrency issues
 2. throw IllegalArgumentExceptions (or similar)
 3. have complex data validation issues (nulls, valid birthday, etc...)
 4. leave the result in an indeterminate state.  

Calling lots of setters on an different class or module that you don't fully understand is rife with dangers, since you don't know all the complexities.  Getters rarely have any of these issues.  When you convert from a B, you are only calling its getters.  So, the best approach is something like
(Java syntax, yours may vary)

    public static A fromB(B b);   or
    
    public A(B b)

True, there may be data validation issues with A, but *A already knows about them*.  The programmer only needs have deep knowledge about A, nor A and B.

Finally, consider what happens when B changes.  They add a new required field, `APIVersion`.  If A is converting to a B, A must change.  *And you are likely to forget about it*.  

But, if A is converting from a B, it might be able to stay the same.  Depends if A cares about `APIVersion`.  If it doesn't care, you leave it alone.  If it does care, *you should have already opened up an issue to add APIVersion*, and it falls into that work naturally.


That said, if you have a lot of things to interconvert, A-Z, this becomes very messy.  And alternative approach is to have everybody understand some common intermediate data representation, say XML, JSON, a database, whatever makes sense for your stuff.  Then, for your conversion, do something like:

      A.readXML(b.toXML());
       ...
      A.readXML(z.toXML());