2012-04-30 8 views
20

सीपीथन अपने दस्तावेज़ीकरण के लिए ऑटोडोक का उपयोग नहीं करता है - हम हाथ से लिखित गद्य का उपयोग करते हैं।स्फटिक ऑटोडोक से एमिट रीस्ट्रक्चर टेक्स्ट?

पीईपी 3144 (आईपैड्रेस मॉड्यूल) के लिए, मैं प्रारंभिक संदर्भ दस्तावेज उत्पन्न करने के लिए स्फिंक्स-एपिडोक का उपयोग करना चाहता हूं। इसका मतलब है कि मैं एक दो-पास आपरेशन चलाना चाहते हैं:

  1. उपयोग स्फिंक्स-apidoc मॉड्यूल autodoc पर निर्भर करता है के लिए एक स्फिंक्स परियोजना फेंकना

  2. भागो एक स्फिंक्स बिल्डर है कि नए reStructuredText स्रोत फ़ाइलें बनाता है , सभी autodoc निर्देशों का इनलाइन reStructuredText सामग्री और मार्कअप है कि एक ही उत्पादन

पहला कदम सीधा है, लेकिन मैं कैसे दूसरे चरण के लिए क्या करने के लिए पता नहीं है और यहां तक ​​कि अच्छा नहीं सोच सकते हैं पैदा करता है के द्वारा बदल दिया एफ खोजने के तरीके या इन लाइनों के साथ किसी भी मौजूदा परियोजनाओं।

+0

ऑटोोडोक द्वारा उत्पन्न आरएसटी फ़ाइलों का उपयोग करने के बारे में क्या गलत है (इसलिए केवल ऑटोडायरेक्टिव कोई पूर्ण पीई-डोमेन परिभाषाएं) और उन्हें विस्तारित करें? – bmu

+0

आईपैड्रेस में पहले से ही व्यापक डॉकस्ट्रिंग हैं, इसलिए मैं उन्हें कॉपी और पेस्ट नहीं करना चाहता हूं और बाकी दस्तावेज़ों के लिए उन्हें हाथ से दोबारा सुधारना चाहता हूं। – ncoghlan

+0

तो आपको उन्हें कॉपी क्यों करना है? आप ऑटो निर्देशों के बीच अपना अतिरिक्त दस्तावेज लिख सकते हैं और स्फिंक्स को इसका अनुवाद करने दें, कॉपी करने की कोई आवश्यकता नहीं है। क्षमा करें शायद मैं आपको नहीं समझता (या आपका प्रश्न)। – bmu

उत्तर

9

मुझे एक ही समस्या थी और एक बार दस्तावेज़ों के निर्माण के लिए मैंने पैच स्फिंक्स के लिए बहुत बदसूरत समाधान का उपयोग किया है, Make Sphinx generate RST class documentation from pydoc देखें।

+0

+1 जैसा कि मुझे लगता है कि आरडी-स्रोत पूरी तरह से ऑटोडोक द्वारा स्वरूपित करने का यही एकमात्र तरीका है। इसे प्राप्त करने के लिए ऑटोोडोक में एक ईवेंट होना चाहिए। (मेरा जवाब भी देखें)। – bmu

+0

धन्यवाद, ऐसा लगता है कि यह अच्छी तरह से काम करेगा। – ncoghlan

2

नहीं एक पूर्ण जवाब है, और अधिक या कम एक प्रारंभिक बिंदु:

autodoc अजगर निर्देशों को ऑटो निर्देशों अनुवाद करता है। तो अनुवादित पायथन निर्देश प्राप्त करने के लिए कोई ऑटोडोक ईवेंट का उपयोग कर सकता है।

उदाहरण के लिए यदि आप निम्नलिखित है mymodule.py:

#!/usr/bin/env python 
# -*- coding: utf-8 -*- 

""" 
This is my module. 
""" 

def my_test_func(a, b=1): 
    """This is my test function""" 
    return a + b 

class MyClass(object): 
    """This is my class""" 

    def __init__(x, y='test'): 
     """The init of my class""" 
     self.x = float(x) 
     self.y = y 

    def my_method(self, z): 
     """This is my method. 

     :param z: a number 
     :type z: float, int 
     :returns: the sum of self.x and z 
     :rtype: float 
     """ 
     return self.x + z 

sphinx-apidoc

mymodule Module 
=============== 

.. automodule:: mymodule 
    :members: 
    :undoc-members: 
    :show-inheritance: 

पैदा करेगा निम्न एक्सटेंशन (या conf.py के अलावा):

NAMES = [] 
DIRECTIVES = {} 

def get_rst(app, what, name, obj, options, signature, 
      return_annotation): 
    doc_indent = ' ' 
    directive_indent = '' 
    if what in ['method', 'attribute']: 
     doc_indent += ' ' 
     directive_indent += ' ' 
    directive = '%s.. py:%s:: %s' % (directive_indent, what, name) 
    if signature: # modules, attributes, ... don't have a signature 
     directive += signature 
    NAMES.append(name) 
    rst = directive + '\n\n' + doc_indent + obj.__doc__ + '\n' 
    DIRECTIVES[name] = rst 

def write_new_docs(app, exception): 
    txt = ['My module documentation'] 
    txt.append('-----------------------\n') 
    for name in NAMES: 
     txt.append(DIRECTIVES[name]) 
    print '\n'.join(txt) 
    with open('../doc_new/generated.rst', 'w') as outfile: 
     outfile.write('\n'.join(txt)) 

def setup(app): 
    app.connect('autodoc-process-signature', get_rst) 
    app.connect('build-finished', write_new_docs) 

आप दे देंगे :

My module documentation 
----------------------- 

.. py:module:: mymodule 


This is my module. 


.. py:class:: mymodule.MyClass(x, y='test') 

    This is my class 

    .. py:method:: mymodule.MyClass.my_method(z) 

     This is my method. 

     :param z: a number 
     :type z: float, int 
     :returns: the sum of self.x and z 
     :rtype: float 


.. py:function:: mymodule.my_test_func(a, b=1) 

    This is my test function 
autodoc रूप

हालांकि किसी भी स्थिति में, जब अनुवाद पूरा हो गया है, तो आगे की प्रक्रिया के autodoc द्वारा किया यहाँ docstrings करने के लिए अनुकूलित किया जाना है उत्सर्जन करता है।

संबंधित मुद्दे