Changeset 11367:9630e1bb6112 in orange


Ignore:
Timestamp:
02/22/13 12:44:33 (14 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Added rst documentation for scheme package.

Fixing docstrings in the process.

Files:
6 added
8 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/scheme/__init__.py

    r11101 r11367  
    11""" 
    2 ===================== 
    3 Scheme Workflow Model 
    4 ===================== 
     2====== 
     3Scheme 
     4====== 
     5 
     6The scheme package implements and defines the underlying workflow model. 
     7 
     8The :class:`Scheme` class represents the workflow and is composed of a set 
     9of :class:`SchemeNode` connected with :class:`SchemeLink`, defining an 
     10directed acyclic graph (DAG). Additionally instances of 
     11:class:`SchemeArrowAnnotation` or :class:`SchemeTextAnnotation` can be 
     12inserted into the scheme. 
    513 
    614""" 
  • Orange/OrangeCanvas/scheme/annotations.py

    r11202 r11367  
    11""" 
     2================== 
    23Scheme Annotations 
     4================== 
    35 
    46""" 
     
    1214 
    1315class BaseSchemeAnnotation(QObject): 
    14     """Base class for scheme annotations. 
    1516    """ 
     17    Base class for scheme annotations. 
     18    """ 
     19    # Signal emitted when the geometry of the annotation changes 
    1620    geometry_changed = Signal() 
    1721 
    1822 
    1923class SchemeArrowAnnotation(BaseSchemeAnnotation): 
    20     """An arrow annotation in the scheme. 
     24    """ 
     25    An arrow annotation in the scheme. 
    2126    """ 
    2227 
     
    3237 
    3338    def set_line(self, start_pos, end_pos): 
    34         """Set arrow lines start and end position ((x, y) tuples). 
     39        """ 
     40        Set arrow lines start and end position (``(x, y)`` tuples). 
    3541        """ 
    3642        if self.__start_pos != start_pos or self.__end_pos != end_pos: 
     
    4046 
    4147    def start_pos(self): 
    42         """Start position. 
     48        """ 
     49        Start position of the arrow (base point). 
    4350        """ 
    4451        return self.__start_pos 
     
    4754 
    4855    def end_pos(self): 
    49         """Arrows end position (arrow head points toward the end).""" 
     56        """ 
     57        End position of the arrow (arrow head points toward the end). 
     58        """ 
    5059        return self.__end_pos 
    5160 
     
    5362 
    5463    def set_geometry(self, (start_pos, end_pos)): 
    55         """Set the geometry of the arrow as a start and end position tuples 
    56         (e.g. `set_geometry(((0, 0), (100, 0))). 
     64        """ 
     65        Set the geometry of the arrow as a start and end position tuples 
     66        (e.g. ``set_geometry(((0, 0), (100, 0))``). 
    5767 
    5868        """ 
     
    6070 
    6171    def geometry(self): 
    62         """Return the start and end positions of the arrow. 
    63  
     72        """ 
     73        Return the start and end positions of the arrow. 
    6474        """ 
    6575        return (self.start_pos, self.end_pos) 
     
    6878 
    6979    def set_color(self, color): 
    70         """Set the fill color for the arrow as a string (#RGB, #RRGGBB, 
    71         #RRRGGGBBB, #RRRRGGGGBBBB format or one of SVG color keyword 
     80        """ 
     81        Set the fill color for the arrow as a string (`#RGB`, `#RRGGBB`, 
     82        `#RRRGGGBBB`, `#RRRRGGGGBBBB` format or one of SVG color keyword 
    7283        names). 
    7384 
     
    8091 
    8192    def color(self): 
    82         """Return the arrow's fill color. 
     93        """ 
     94        The arrow's fill color. 
    8395        """ 
    8496        return self.__color 
     
    88100 
    89101class SchemeTextAnnotation(BaseSchemeAnnotation): 
    90     """Text annotation in the scheme. 
    91102    """ 
     103    Text annotation in the scheme. 
     104    """ 
     105 
     106    # Signal emitted when the annotation text changes. 
    92107    text_changed = Signal(unicode) 
     108 
     109    # Signal emitted when the annotation text font changes. 
    93110    font_changed = Signal(dict) 
    94111 
     
    101118 
    102119    def set_rect(self, (x, y, w, h)): 
    103         """Set the text geometry bounding rectangle 
    104         ((x, y, width, height) tuple). 
     120        """ 
     121        Set the text geometry bounding rectangle (``(x, y, width, height)`` 
     122        tuple). 
    105123 
    106124        """ 
     
    111129 
    112130    def rect(self): 
    113         """Text bounding rectangle 
     131        """ 
     132        Text bounding rectangle 
    114133        """ 
    115134        return self.__rect 
     
    118137 
    119138    def set_geometry(self, rect): 
    120         """Set the text geometry (same as `set_rect`) 
     139        """ 
     140        Set the text geometry (same as ``set_rect``) 
    121141        """ 
    122142        self.set_rect(rect) 
    123143 
    124144    def geometry(self): 
     145        """ 
     146        Text annotation geometry (same as ``rect`` 
     147        """ 
    125148        return self.rect 
    126149 
     
    128151 
    129152    def set_text(self, text): 
    130         """Set the annotation text. 
     153        """ 
     154        Set the annotation text. 
    131155        """ 
    132156        check_type(text, (basestring, QString)) 
     
    137161 
    138162    def text(self): 
    139         """Annotation text. 
     163        """ 
     164        Annotation text. 
    140165        """ 
    141166        return self.__text 
     
    144169 
    145170    def set_font(self, font): 
    146         """Set the annotation's font as a dictionary of font properties 
     171        """ 
     172        Set the annotation's font as a dictionary of font properties 
    147173        (at the moment only family and size are used). 
    148174 
    149             annotation.set_font({"family": "Helvetica", "size": 16}) 
     175            >>> annotation.set_font({"family": "Helvetica", "size": 16}) 
    150176 
    151177        """ 
     
    157183 
    158184    def font(self): 
    159         """Return the annotation's font property dictionary. 
     185        """ 
     186        Annotation's font property dictionary. 
    160187        """ 
    161188        return dict(self.__font) 
  • Orange/OrangeCanvas/scheme/link.py

    r11302 r11367  
    1515 
    1616def compatible_channels(source_channel, sink_channel): 
    17     """Do the channels in link have compatible types, i.e. can they be 
     17    """ 
     18    Do the channels in link have compatible types, i.e. can they be 
    1819    connected based on their type. 
    1920 
     
    2829 
    2930def can_connect(source_node, sink_node): 
    30     """Return True if any output from `source_node` can be connected to 
     31    """ 
     32    Return True if any output from `source_node` can be connected to 
    3133    any input of `sink_node`. 
    3234 
     
    3638 
    3739def possible_links(source_node, sink_node): 
    38     """Return a list of (OutputSignal, InputSignal) tuples, that 
     40    """ 
     41    Return a list of (OutputSignal, InputSignal) tuples, that 
    3942    can connect the two nodes. 
    4043 
     
    4952 
    5053class SchemeLink(QObject): 
    51     """A instantiation of a link between two widget nodes in the scheme. 
     54    """ 
     55    A instantiation of a link between two :class:`.SchemeNode` instances 
     56    in a :class:`.Scheme`. 
    5257 
    5358    Parameters 
    5459    ---------- 
    55     source_node : `SchemeNode` 
     60    source_node : :class:`.SchemeNode` 
    5661        Source node. 
    57     source_channel : `OutputSignal` 
     62    source_channel : :class:`OutputSignal` 
    5863        The source widget's signal. 
    59     sink_node : `SchemeNode` 
     64    sink_node : :class:`.SchemeNode` 
    6065        The sink node. 
    61     sink_channel : `InputSignal` 
     66    sink_channel : :class:`InputSignal` 
    6267        The sink widget's input signal. 
    6368    properties : `dict` 
     
    105110 
    106111    def source_type(self): 
    107         """Return the type of the source channel. 
     112        """ 
     113        Return the type of the source channel. 
    108114        """ 
    109115        return name_lookup(self.source_channel.type) 
    110116 
    111117    def sink_type(self): 
    112         """Return the type of the sink channel. 
     118        """ 
     119        Return the type of the sink channel. 
    113120        """ 
    114121        return name_lookup(self.sink_channel.type) 
    115122 
    116123    def is_dynamic(self): 
    117         """Is this link dynamic. 
     124        """ 
     125        Is this link dynamic. 
    118126        """ 
    119127        return self.source_channel.dynamic and \ 
     
    121129            not (self.sink_type() is self.source_type()) 
    122130 
    123     def enabled(self): 
    124         """Is this link enabled. 
     131    def set_enabled(self, enabled): 
    125132        """ 
    126         return self.__enabled 
    127  
    128     def set_enabled(self, enabled): 
    129         """Enable/disable the link. 
     133        Enable/disable the link. 
    130134        """ 
    131135        if self.__enabled != enabled: 
     
    133137            self.enabled_changed.emit(enabled) 
    134138 
     139    def enabled(self): 
     140        """ 
     141        Is this link enabled. 
     142        """ 
     143        return self.__enabled 
     144 
    135145    enabled = Property(bool, fget=enabled, fset=set_enabled) 
    136146 
    137147    def set_dynamic_enabled(self, enabled): 
    138         """Enable/disable the dynamic link. Has no effect if 
    139         the link is not dynamic. 
     148        """ 
     149        Enable/disable the dynamic link. Has no effect if the link 
     150        is not dynamic. 
    140151 
    141152        """ 
     
    145156 
    146157    def dynamic_enabled(self): 
    147         """Is this dynamic link and `dynamic_enabled` set to True 
     158        """ 
     159        Is this a dynamic link and is `dynamic_enabled` set to `True` 
    148160        """ 
    149161        return self.is_dynamic() and self.__dynamic_enabled 
    150162 
    151163    dynamic_enabled = Property(bool, fget=dynamic_enabled, 
    152                                  fset=set_dynamic_enabled) 
     164                               fset=set_dynamic_enabled) 
    153165 
    154166    def set_tool_tip(self, tool_tip): 
    155         """Set the link tool tip. 
     167        """ 
     168        Set the link tool tip. 
    156169        """ 
    157170        if self.__tool_tip != tool_tip: 
     
    159172 
    160173    def tool_tip(self): 
    161         """Return the link's tool tip 
     174        """ 
     175        Link tool tip. 
    162176        """ 
    163177        return self.__tool_tip 
    164178 
    165179    tool_tip = Property(str, fget=tool_tip, 
    166                           fset=set_tool_tip) 
     180                        fset=set_tool_tip) 
    167181 
    168182    def __str__(self): 
  • Orange/OrangeCanvas/scheme/node.py

    r11302 r11367  
    1212 
    1313class SchemeNode(QObject): 
    14     """A widget node instantiation in the scheme. 
     14    """ 
     15    A node in a :class:`.Scheme`. 
    1516 
    1617    Parameters 
    1718    ---------- 
    18     description : `WidgetDescription` 
    19         Widget description. 
    20     title : `str` 
    21         Node title string (if None description.name is used). 
     19    description : :class:`WidgetDescription` 
     20        Node description instance. 
     21    title : str, optional 
     22        Node title string (if None `description.name` is used). 
    2223    position : tuple 
    23         (x, y) two-tuple for node position in a visual display. 
    24     properties : `dict` 
    25         Additional instance properties (settings, widget geometry, ...) 
    26     parent : `QObject` 
     24        (x, y) tuple of floats for node position in a visual display. 
     25    properties : dict 
     26        Additional extra instance properties (settings, widget geometry, ...) 
     27    parent : :class:`QObject` 
    2728        Parent object. 
    2829 
     
    4445 
    4546    def input_channels(self): 
    46         """Return the input channels for the node. 
    4747        """ 
    48         return self.description.inputs 
     48        Return a list of input channels (:class:`InputSignal`) for the node. 
     49        """ 
     50        return list(self.description.inputs) 
    4951 
    5052    def output_channels(self): 
    51         """Return the output channels for the node. 
    5253        """ 
    53         return self.description.outputs 
     54        Return a list of output channels (:class:`OutputSignal`) for the node. 
     55        """ 
     56        return list(self.description.outputs) 
    5457 
    5558    def input_channel(self, name): 
    56         """Return the input channel matching `name`. Raise an ValueError 
     59        """ 
     60        Return the input channel matching `name`. Raise a `ValueError` 
    5761        if not found. 
    5862 
     
    6569 
    6670    def output_channel(self, name): 
    67         """Return the output channel matching `name`. Raise an ValueError 
     71        """ 
     72        Return the output channel matching `name`. Raise an `ValueError` 
    6873        if not found. 
    6974 
     
    7580                         (name, self.description.name)) 
    7681 
    77     def __str__(self): 
    78         return u"SchemeNode(description_id=%s, title=%r, ...)" % \ 
    79                 (str(self.description.id), self.title) 
    80  
    81     def __repr__(self): 
    82         return str(self) 
    83  
     82    # The title of the node has changed 
    8483    title_changed = Signal(unicode) 
    85     """The title of the node has changed""" 
    8684 
    8785    def set_title(self, title): 
    88         """Set the node's title 
     86        """ 
     87        Set the node title. 
    8988        """ 
    9089        if self.__title != title: 
     
    9392 
    9493    def title(self): 
    95         """Return the nodes title. 
     94        """ 
     95        Return the node title. 
    9696        """ 
    9797        return self.__title 
     
    9999    title = Property(unicode, fset=set_title, fget=title) 
    100100 
     101    # Position of the node in the scheme has changed 
    101102    position_changed = Signal(tuple) 
    102     """Position of the node in the scheme has changed""" 
    103103 
    104104    def set_position(self, pos): 
    105         """Set the position of the node 
     105        """ 
     106        Set the position (``(x, y)`` tuple) of the node. 
    106107        """ 
    107108        if self.__position != pos: 
     
    110111 
    111112    def position(self): 
    112         """(x, y) tuple containing the position of the node in the scheme. 
     113        """ 
     114        ``(x, y)`` tuple containing the position of the node in the scheme. 
    113115        """ 
    114116        return self.__position 
     
    116118    position = Property(tuple, fset=set_position, fget=position) 
    117119 
     120    # Node's progress value has changed. 
    118121    progress_changed = Signal(float) 
    119     """Node's progress value has changed.""" 
    120122 
    121123    def set_progress(self, value): 
    122         """Set the progress value. 
     124        """ 
     125        Set the progress value. 
    123126        """ 
    124127        if self.__progress != value: 
     
    127130 
    128131    def progress(self): 
    129         """Return the current progress value. -1 if progress is not set. 
     132        """ 
     133        Return the current progress value. -1 if progress is not set. 
    130134        """ 
    131135        return self.__progress 
     
    133137    progress = Property(float, fset=set_progress, fget=progress) 
    134138 
     139    # Node's processing state has changed. 
    135140    processing_state_changed = Signal(int) 
    136     """Node's processing state has changed.""" 
    137141 
    138142    def set_processing_state(self, state): 
    139         """Set the node's processing state 
     143        """ 
     144        Set the node processing state. 
    140145        """ 
    141146        if self.__processing_state != state: 
     
    144149 
    145150    def processing_state(self): 
    146         """Return the node's processing state, 0 for not processing, 1 the 
     151        """ 
     152        Return the node processing state, 0 for not processing, 1 the 
    147153        node is busy. 
    148154 
     
    151157 
    152158    processing_state = Property(int, fset=set_processing_state, 
    153                                   fget=processing_state) 
     159                                fget=processing_state) 
    154160 
    155161    def set_tool_tip(self, tool_tip): 
     
    161167 
    162168    tool_tip = Property(str, fset=set_tool_tip, 
    163                           fget=tool_tip) 
     169                        fget=tool_tip) 
     170 
     171    def __str__(self): 
     172        return u"SchemeNode(description_id=%s, title=%r, ...)" % \ 
     173                (str(self.description.id), self.title) 
     174 
     175    def __repr__(self): 
     176        return str(self) 
  • Orange/OrangeCanvas/scheme/readwrite.py

    r11307 r11367  
    11""" 
    22Scheme save/load routines. 
     3 
    34""" 
    45import sys 
    5 import shutil 
    66 
    77from xml.etree.ElementTree import TreeBuilder, Element, ElementTree, parse 
     
    3030def sniff_version(stream): 
    3131    """ 
    32     Parse a scheme stream and return the scheme's version string. 
     32    Parse a scheme stream and return the scheme's serialization 
     33    version string. 
     34 
    3335    """ 
    3436    doc = parse(stream) 
     
    447449    """ 
    448450    Indent an instance of a :class:`Element`. Based on 
    449     `http://effbot.org/zone/element-lib.htm#prettyprint`_). 
     451    (http://effbot.org/zone/element-lib.htm#prettyprint). 
    450452 
    451453    """ 
  • Orange/OrangeCanvas/scheme/scheme.py

    r11275 r11367  
    11""" 
     2=============== 
    23Scheme Workflow 
     4=============== 
     5 
     6The :class:`Scheme` class defines a DAG (Directed Acyclic Graph) workflow. 
    37 
    48""" 
     
    3236 
    3337class Scheme(QObject): 
    34     """An QObject representing the scheme widget workflow 
    35     with annotations, etc. 
    36  
    3738    """ 
    38  
     39    An :class:`QObject` subclass representing the scheme widget workflow 
     40    with annotations. 
     41 
     42    Parameters 
     43    ---------- 
     44    parent : :class:`QObject` 
     45        A parent QObject item (default `None`). 
     46    title : str 
     47        The scheme title. 
     48    description : str 
     49        A longer description of the scheme. 
     50 
     51 
     52    Attributes 
     53    ---------- 
     54    nodes : list of :class:`.SchemeNode` 
     55        A list of all the nodes in the scheme. 
     56 
     57    links : list of :class:`.SchemeLink` 
     58        A list of all links in the scheme. 
     59 
     60    annotations : list of :class:`BaseSchemeAnnotation` 
     61        A list of all the annotations in the scheme. 
     62 
     63    """ 
     64 
     65    # Signal emitted when a `node` is added to the scheme. 
    3966    node_added = Signal(SchemeNode) 
     67 
     68    # Signal emitted when a `node` is removed from the scheme. 
    4069    node_removed = Signal(SchemeNode) 
    4170 
     71    # Signal emitted when a `link` is added to the scheme. 
    4272    link_added = Signal(SchemeLink) 
     73 
     74    # Signal emitted when a `link` is removed from the scheme. 
    4375    link_removed = Signal(SchemeLink) 
    4476 
    45     topology_changed = Signal() 
     77    # Signal emitted when a `annotation` is added to the scheme. 
     78    annotation_added = Signal(BaseSchemeAnnotation) 
     79 
     80    # Signal emitted when a `annotation` is removed from the scheme. 
     81    annotation_removed = Signal(BaseSchemeAnnotation) 
     82 
     83    # Signal emitted when the title of scheme changes. 
     84    title_changed = Signal(unicode) 
     85 
     86    # Signal emitted when the description of scheme changes. 
     87    description_changed = Signal(unicode) 
    4688 
    4789    node_state_changed = Signal() 
    4890    channel_state_changed = Signal() 
    49  
    50     annotation_added = Signal(BaseSchemeAnnotation) 
    51     annotation_removed = Signal(BaseSchemeAnnotation) 
    52  
    53     node_property_changed = Signal(SchemeNode, str, object) 
    54  
    55     title_changed = Signal(unicode) 
    56     description_changed = Signal(unicode) 
     91    topology_changed = Signal() 
    5792 
    5893    def __init__(self, parent=None, title=None, description=None): 
     
    71106    @property 
    72107    def nodes(self): 
     108        """ 
     109        A list of all nodes (:class:`.SchemeNode`) currently in the scheme. 
     110        """ 
    73111        return list(self.__nodes) 
    74112 
    75113    @property 
    76114    def links(self): 
     115        """ 
     116        A list of all links (:class:`.SchemeLink`) currently in the scheme. 
     117        """ 
    77118        return list(self.__links) 
    78119 
    79120    @property 
    80121    def annotations(self): 
     122        """ 
     123        A list of all annotations (:class:`.BaseSchemeAnnotation`) in the 
     124        scheme. 
     125 
     126        """ 
    81127        return list(self.__annotations) 
    82128 
    83129    def set_title(self, title): 
     130        """ 
     131        Set the scheme title text. 
     132        """ 
    84133        if self.__title != title: 
    85134            self.__title = title 
     
    87136 
    88137    def title(self): 
     138        """ 
     139        The title (human readable string) of the scheme. 
     140        """ 
    89141        return self.__title 
    90142 
     
    92144 
    93145    def set_description(self, description): 
     146        """ 
     147        Set the scheme description text. 
     148        """ 
    94149        if self.__description != description: 
    95150            self.__description = description 
     
    97152 
    98153    def description(self): 
     154        """ 
     155        Scheme description text. 
     156        """ 
    99157        return self.__description 
    100158 
     
    102160 
    103161    def add_node(self, node): 
    104         """Add a node to the scheme. 
     162        """ 
     163        Add a node to the scheme. An error is raised if the node is 
     164        already in the scheme. 
    105165 
    106166        Parameters 
    107167        ---------- 
    108         node : `SchemeNode` 
    109             Node to add to the scheme. 
     168        node : :class:`.SchemeNode` 
     169            Node instance to add to the scheme. 
    110170 
    111171        """ 
     
    120180    def new_node(self, description, title=None, position=None, 
    121181                 properties=None): 
    122         """Create a new SchemeNode and add it to the scheme. 
    123         Same as: 
     182        """ 
     183        Create a new :class:`.SchemeNode` and add it to the scheme. 
     184 
     185        Same as:: 
    124186 
    125187            scheme.add_node(SchemeNode(description, title, position, 
    126188                                       properties)) 
     189 
     190        Parameters 
     191        ---------- 
     192        description : :class:`WidgetDescription` 
     193            The new node's description. 
     194        title : str, optional 
     195            Optional new nodes title. By default `description.name` is used. 
     196        position : `(x, y)` tuple of floats, optional 
     197            Optional position in a 2D space. 
     198        properties : dict, optional 
     199            A dictionary of optional extra properties. 
     200 
     201        See also 
     202        -------- 
     203        SchemeNode, Scheme.add_node 
    127204 
    128205        """ 
     
    138215 
    139216    def remove_node(self, node): 
    140         """Remove a `node` from the scheme. All links into and out of the node 
    141         are also removed. 
     217        """ 
     218        Remove a `node` from the scheme. All links into and out of the 
     219        `node` are also removed. If the node in not in the scheme an error 
     220        is raised. 
     221 
     222        Parameters 
     223        ---------- 
     224        node : :class:`.SchemeNode` 
     225            Node instance to remove. 
    142226 
    143227        """ 
     
    152236 
    153237    def __remove_node_links(self, node): 
    154         """Remove all links for node. 
     238        """ 
     239        Remove all links for node. 
    155240        """ 
    156241        links_in, links_out = [], [] 
     
    166251    def add_link(self, link): 
    167252        """ 
    168         Add a link to the scheme. 
     253        Add a `link` to the scheme. 
     254 
     255        Parameters 
     256        ---------- 
     257        link : :class:`.SchemeLink` 
     258            An initialized link instance to add to the scheme. 
     259 
    169260        """ 
    170261        check_type(link, SchemeLink) 
     
    186277        Create a new SchemeLink and add it to the scheme. 
    187278 
    188         Same as: 
     279        Same as:: 
    189280 
    190281            scheme.add_link(SchemeLink(source_node, source_channel, 
    191                                        sink_node, sink_channel) 
     282                                       sink_node, sink_channel)) 
     283 
     284        Parameters 
     285        ---------- 
     286        source_node : :class:`.SchemeNode` 
     287            Source node of the new link. 
     288        source_channel : :class:`OutputSignal` 
     289            Source channel of the new node. The instance must be from 
     290            `source_node.output_channels()` 
     291        sink_node : :class:`.SchemeNode` 
     292            Sink node of the new link. 
     293        sink_channel : :class:`InputSignal` 
     294            Sink channel of the new node. The instance must be from 
     295            `sink_node.input_channels()` 
     296 
     297        See also 
     298        -------- 
     299        SchemeLink, Scheme.add_link 
    192300 
    193301        """ 
     
    198306 
    199307    def remove_link(self, link): 
    200         """Remove a link from the scheme. 
     308        """ 
     309        Remove a link from the scheme. 
     310 
     311        Parameters 
     312        ---------- 
     313        link : :class:`.SchemeLink` 
     314            Link instance to remove. 
     315 
    201316        """ 
    202317        check_arg(link in self.__links, 
     
    213328    def check_connect(self, link): 
    214329        """ 
    215         Check if the link can be added to the scheme. 
     330        Check if the `link` can be added to the scheme. 
    216331 
    217332        Can raise: 
    218             - `TypeError` if link is not an instance of :class:`SchemeLink`. 
    219             - `SchemeCycleError` if the link would introduce a cycle 
    220             - `IncompatibleChannelTypeError` if the channel types are not 
    221                compatible 
    222             - `SinkChannelError` if a sink channel has a `Single` flag 
    223                specification and there is already connected. 
    224             - `DuplicatedLinkError` if a link duplicates an already present 
    225                link. 
     333            - :class:`TypeError` if `link` is not an instance of 
     334              :class:`.SchemeLink` 
     335            - :class:`SchemeCycleError` if the `link` would introduce a cycle 
     336            - :class:`IncompatibleChannelTypeError` if the channel types are 
     337              not compatible 
     338            - :class:`SinkChannelError` if a sink channel has a `Single` flag 
     339              specification and the channel is already connected. 
     340            - :class:`DuplicatedLinkError` if a `link` duplicates an already 
     341              present link. 
    226342 
    227343        """ 
     
    258374 
    259375    def creates_cycle(self, link): 
    260         """Would the `link` if added to the scheme introduce a cycle. 
     376        """ 
     377        Would the `link` if added to the scheme introduce a cycle. 
    261378        """ 
    262379        check_type(link, SchemeLink) 
     
    267384 
    268385    def compatible_channels(self, link): 
    269         """Do the channels in link have compatible types. 
     386        """ 
     387        Do the channels in `link` have compatible types. 
    270388        """ 
    271389        check_type(link, SchemeLink) 
     
    282400 
    283401    def upstream_nodes(self, start_node): 
    284         """Return a set of all nodes upstream from `start_node`. 
     402        """ 
     403        Return a set of all nodes upstream from `start_node`. 
    285404        """ 
    286405        visited = set() 
     
    298417 
    299418    def downstream_nodes(self, start_node): 
    300         """Return a set of all nodes downstream from `start_node`. 
     419        """ 
     420        Return a set of all nodes downstream from `start_node`. 
    301421        """ 
    302422        visited = set() 
     
    314434 
    315435    def is_ancestor(self, node, child): 
    316         """Return True if `node` is an ancestor node of `child` (is upstream 
     436        """ 
     437        Return True if `node` is an ancestor node of `child` (is upstream 
    317438        of the child in the workflow). Both nodes must be in the scheme. 
    318439 
     
    321442 
    322443    def children(self, node): 
    323         """Return a set of all children of `node`. 
     444        """ 
     445        Return a set of all children of `node`. 
    324446        """ 
    325447        return set(link.sink_node for link in self.output_links(node)) 
    326448 
    327449    def parents(self, node): 
    328         """Return a set if all parents of `node`. 
     450        """ 
     451        Return a set of all parents of `node`. 
    329452        """ 
    330453        return set(link.source_node for link in self.input_links(node)) 
    331454 
    332455    def input_links(self, node): 
    333         """Return all input links connected to the `node`. 
     456        """ 
     457        Return all input links connected to the `node` instance. 
    334458        """ 
    335459        return self.find_links(sink_node=node) 
    336460 
    337461    def output_links(self, node): 
    338         """Return all output links connected to the `node`. 
     462        """ 
     463        Return all output links connected to the `node` instance. 
    339464        """ 
    340465        return self.find_links(source_node=node) 
     
    355480 
    356481    def propose_links(self, source_node, sink_node): 
    357         """Return a list of ordered (`OutputSignal`, `InputSignal`, weight) 
    358         tuples that could be added to the scheme between `source_node` and 
    359         `sink_node`. 
     482        """ 
     483        Return a list of ordered (:class:`OutputSignal`, 
     484        :class:`InputSignal`, weight) tuples that could be added to 
     485        the scheme between `source_node` and `sink_node`. 
    360486 
    361487        .. note:: This can depend on the links already in the scheme. 
     
    398524 
    399525    def add_annotation(self, annotation): 
    400         """Add an annotation (`BaseSchemeAnnotation`) subclass to the scheme. 
     526        """ 
     527        Add an annotation (:class:`BaseSchemeAnnotation` subclass) instance 
     528        to the scheme. 
    401529 
    402530        """ 
     
    409537 
    410538    def remove_annotation(self, annotation): 
     539        """ 
     540        Remove the `annotation` instance from the scheme. 
     541        """ 
    411542        check_arg(annotation in self.__annotations, 
    412543                  "Annotation is not in the scheme.") 
     
    415546 
    416547    def save_to(self, stream, pretty=True): 
    417         """Save the scheme as an xml formated file to `stream` 
     548        """ 
     549        Save the scheme as an xml formated file to `stream` 
    418550        """ 
    419551        if isinstance(stream, basestring): 
     
    423555 
    424556    def load_from(self, stream): 
    425         """Load the scheme from xml formated stream. 
     557        """ 
     558        Load the scheme from xml formated stream. 
    426559        """ 
    427560        if self.__nodes or self.__links or self.__annotations: 
  • Orange/OrangeCanvas/scheme/utils.py

    r11101 r11367  
    66 
    77def name_lookup(qualified_name, globals={}): 
    8     """Return the object referenced by a qualified name (doted name). 
     8    """ 
     9    Return the object referenced by a qualified name (doted name). 
    910    """ 
    1011    module_name, class_name = qualified_name.rsplit(".", 1) 
     
    1415 
    1516def qualified_name(qualified_object): 
    16     """Return a qualifeid name for `qualified_obj` (type or function). 
     17    """ 
     18    Return a qualified name for `qualified_obj` (type or function). 
    1719    """ 
    1820    return "%s.%s" % (qualified_object.__module__, qualified_object.__name__) 
  • docs/canvas/index.rst

    r11366 r11367  
    88 
    99   gui 
     10   scheme 
Note: See TracChangeset for help on using the changeset viewer.