def __init__(self, initial_tagger, templates, trace=0,
              **property_names):
     self._initial_tagger = initial_tagger
     self._templates = templates
     self._trace = trace
     self._property_names = property_names
     PropertyIndirectionMixIn.__init__(self, **property_names)
 def __init__(self, preterminal_tags=False, **property_names):
     """
     @param preterminal_tags: If true, then treat preterminal
         nodes as tags.
     @type preterminal_tags: C{boolean}
     """
     PropertyIndirectionMixIn.__init__(self, **property_names)
     self._preterminal_tags = preterminal_tags
     self._source = None # <- not thread-safe.
 def __init__(self, encoders, **property_names):
     """
     Create a new merged feature encoder.
     
     @param encoders: The basic feature encoders whose output
         should be combined to form this encoder's output.
     """
     PropertyIndirectionMixIn.__init__(self, **property_names)
     self._encoders = encoders
 def __init__(self, initial_tagger, rules, **property_names):
     """
     @param initial_tagger: The initial tagger
     @type initial_tagger: L{TaggerI}
     @param rules: An ordered list of transformation rules that
         should be used to correct the initial tagging.
     @type rules: C{list} of L{BrillRuleI}
     """
     self._initial_tagger = initial_tagger
     self._rules = rules
     PropertyIndirectionMixIn.__init__(self, **property_names)
 def __init__(self, top_node='S', chunk_node='CHUNK', **property_names):
     """
     @include: AbstractTokenizer.__init__
     @type chunk_node: C{string}
     @param chunk_node: The node label that should be used for
         chunk subtrees.  This is typically a short string
         describing the type of information contained by the chunk,
         such as C{"NP"} for base noun phrases.
     """
     PropertyIndirectionMixIn.__init__(self, **property_names)
     self._chunk_node = chunk_node
     self._top_node = top_node
    def __init__(self, **property_names):
        """
        Construct a new tokenizer.

        @type property_names: C{dict}
        @param property_names: A dictionary that can be used to override
            the default property names.  Each entry maps from a
            default property name to a new property name.
        """
        if self.__class__ == AbstractTokenizer:
            raise AssertionError, "Abstract classes can't be instantiated"
        PropertyIndirectionMixIn.__init__(self, **property_names)
 def __init__(self, reverse=False, **property_names):
     """
     Construct a new sequential tagger.
     
     @param reverse: If true, then assign tags to subtokens in
         reverse sequential order (i.e., from right to left).
     @type property_names: C{dict}
     @param property_names: A dictionary that can be used to override
         the default property names.  Each entry maps from a
         default property name to a new property name.
     """
     self._reverse = reverse
     PropertyIndirectionMixIn.__init__(self, **property_names)
 def __init__(self, **property_names):
     """
     Create a new stemmer.
     
     @type property_names: C{dict}
     @param property_names: A dictionary that can be used to override
         the default property names.  Each entry maps from a
         default property name to a new property name.
     """
     # Make sure we're not directly instantiated:
     if self.__class__ == AbstractStemmer:
         raise AssertionError, "Abstract classes can't be instantiated"
     PropertyIndirectionMixIn.__init__(self, **property_names)
 def __init__(self, chunk_types = ['LOCATION', 'ORGANIZATION', 'PERSON', 
         'DURATION', 'DATE', 'CARDINAL', 'PERCENT', 'MONEY', 'MEASURE'],
              **property_names):
     """
     Create a new C{IeerChunkedTokenizer}.
     
     @type chunk_types: C{string}
     @param chunk_types: A list of the node types to be extracted
         from the input.  Possible node types are
         C{'LOCATION'}, C{'ORGANIZATION'}, C{'PERSON'},
         C{'DURATION'}, C{'DATE'}, C{'CARDINAL'}, C{'PERCENT'},
         C{'MONEY'}, C{'MEASURE'}
     """
     PropertyIndirectionMixIn.__init__(self, **property_names)
     self._chunk_types = chunk_types
 def __init__(self, base_encoder, C=None, **property_names):
     """
     @param C: The correction constant for this encoder.  This
         value must be at least as great as the highest sum of
         feature vectors that could be returned by C{base_encoder}.
         If no value is given, a default of C{len(base_encoder)} is
         used.  While this value is safe (for boolean feature
         vectors), it is highly conservative, and usually leads to
         poor performance.
     @type C: C{int}
     """
     PropertyIndirectionMixIn.__init__(self, **property_names)
     self._encoder = base_encoder
     if C is None:
         self._C = encoder.num_features()
     else:
         self._C = C
    def __init__(self, classes, weights, **property_names):
        """
        Construct a new conditional exponential classifier model.
        Typically, new classifier models are created by
        C{ClassifierTrainer}s.

        @type classes: C{list}
        @param classes: A list of the classes that can be generated by
            this classifier.  The order of these classes must
            correspond to the order of the weights.
        @type weights: C{list} of C{float}
        @param weights:  The feature weight vector for this classifier.
            Weight M{w[i,j]} is encoded by C{weights[i+j*N]}, where
            C{N} is the length of the feature vector.
        """
        PropertyIndirectionMixIn.__init__(self, **property_names)
        self._classes = classes # <- order matters here!
        self._weights = weights
    def __init__(self, feature_name, values, **property_names):
        """
        Create a new feature encoder that encodes the feature with the
        given name.

        @type feature_name: C{string}
        @param feature_name: The name of the feature to encode.
        @type values: C{list}
        @param values: A list of the feature values of subvalues that
            the feature is known to take.  A feature vector index
            will also be created for unseen values.
        """
        PropertyIndirectionMixIn.__init__(self, **property_names)
        self._feature_name = feature_name
        
        # Initialize the mappings between basic values and feature
        # vector indices.  Reserve index 0 for unseen feature values.
        self._index_to_val = ['<unknown>']+list(values)
        self._val_to_index = dict([(v,i+1) for (i,v) in enumerate(values)])
    def __init__(self,  **property_names):
        PropertyIndirectionMixIn.__init__(self, **property_names)

        # A token reader for processing sentences.
        self._sent_reader = ChunkedTaggedTokenReader(
            top_node='S', chunk_node='NP', **property_names)
 def __init__(self, **property_names):
     PropertyIndirectionMixIn.__init__(self, **property_names)
 def __init__(self, chunk_types=None, **property_names):
     PropertyIndirectionMixIn.__init__(self, **property_names)
     self._chunk_types = chunk_types