Ignore:
Timestamp:
8 Mar 2012, 19:00:51 (13 years ago)
Author:
uli
Message:

Rename all non-locales stuff from sirp to kofa.

Location:
main/waeup.kofa/trunk/src/waeup/kofa/utils
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/api.txt

    r4973 r7811  
    1 :mod:`waeup.sirp.utils` -- misc. helpers
     1:mod:`waeup.kofa.utils` -- misc. helpers
    22****************************************
    33
    4 .. module:: waeup.sirp.utils
     4.. module:: waeup.kofa.utils
    55
    66Components and other stuff of general interest.
    … …  
    99==========
    1010
    11 The :mod:`waeup.sirp.utils` module provides the following submodules:
     11The :mod:`waeup.kofa.utils` module provides the following submodules:
    1212
    1313.. toctree::

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/batching.py

    r7649 r7811  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """SIRP components for batch processing.
     18"""KOFA components for batch processing.
    1919
    2020Batch processors eat CSV files to add, update or remove large numbers
    … …  
    3131from zope.interface import Interface
    3232from zope.schema import getFields
    33 from waeup.sirp.interfaces import (
     33from waeup.kofa.interfaces import (
    3434    IBatchProcessor, FatalCSVError, DuplicationError, IObjectConverter)
    3535

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/batching.txt

    r6824 r7811  
    1 :mod:`waeup.sirp.utils.batching` -- Batch processing
     1:mod:`waeup.kofa.utils.batching` -- Batch processing
    22****************************************************
    33
    … …  
    188188All we need, is a batch processor now.
    189189
    190     >>> from waeup.sirp.utils.batching import BatchProcessor
     190    >>> from waeup.kofa.utils.batching import BatchProcessor
    191191    >>> class CaveProcessor(BatchProcessor):
    192192    ...   util_name = 'caveprocessor'

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/converters.py

    r7709 r7811  
    2727from zope.interface import Interface
    2828from zope.publisher.browser import TestRequest
    29 from waeup.sirp.interfaces import IObjectConverter
     29from waeup.kofa.interfaces import IObjectConverter
    3030
    3131class ExtendedCheckBoxWidget(CheckBoxWidget):

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/converters.txt

    r7321 r7811  
    1 :mod:`waeup.sirp.utils.converters` -- Converters
     1:mod:`waeup.kofa.utils.converters` -- Converters
    22************************************************
    33
    4 .. module:: waeup.sirp.utils.converters
     4.. module:: waeup.kofa.utils.converters
    55
    66Converters for :mod:`zope.schema` based data.
    … …  
    1010
    1111.. :NOdoctest:
    12 .. :NOlayer: waeup.sirp.testing.SIRPUnitTestLayer
     12.. :NOlayer: waeup.kofa.testing.KOFAUnitTestLayer
    1313
    1414
    … …  
    2121   'non-values'. Current setting is:
    2222
    23       >>> from waeup.sirp.utils.converters import NONE_STRING_VALUE
     23      >>> from waeup.kofa.utils.converters import NONE_STRING_VALUE
    2424      >>> NONE_STRING_VALUE
    2525      ''
    … …  
    3232========
    3333
    34 The :mod:`waeup.sirp.utils.converters` module is basically a collection of
     34The :mod:`waeup.kofa.utils.converters` module is basically a collection of
    3535adapters for field types of :mod:`zope.schema`.
    3636
    … …  
    4848   `zope.schema.Choice` or similar.
    4949
    50    .. method:: provides(waeup.sirp.interfaces.ISchemaTypeConverter)
     50   .. method:: provides(waeup.kofa.interfaces.ISchemaTypeConverter)
    5151
    5252   .. method:: _convertValueFromString(string)
    … …  
    111111   .. method:: adapts(zope.schema.IText)
    112112
    113    .. method:: provides(waeup.sirp.interfaces.ISchemaTypeConverter)
     113   .. method:: provides(waeup.kofa.interfaces.ISchemaTypeConverter)
    114114
    115115   .. method:: fromString(string[, strict=True])
    … …  
    150150   .. method:: adapts(zope.schema.IBool)
    151151
    152    .. method:: provides(waeup.sirp.interfaces.ISchemaTypeConverter)
     152   .. method:: provides(waeup.kofa.interfaces.ISchemaTypeConverter)
    153153
    154154   .. method:: fromString(string[, strict=True])
    … …  
    191191   .. method:: adapts(zope.schema.IInt)
    192192
    193    .. method:: provides(waeup.sirp.interfaces.ISchemaTypeConverter)
     193   .. method:: provides(waeup.kofa.interfaces.ISchemaTypeConverter)
    194194
    195195   .. method:: fromString(string[, strict=True])
    … …  
    232232   .. method:: adapts(zope.schema.IChoice)
    233233
    234    .. method:: provides(waeup.sirp.interfaces.ISchemaTypeConverter)
     234   .. method:: provides(waeup.kofa.interfaces.ISchemaTypeConverter)
    235235
    236236   .. method:: fromString(string[, strict=False])
    … …  
    272272----------------------
    273273
    274 .. autoclass:: waeup.sirp.utils.converters.DateConverter
     274.. autoclass:: waeup.kofa.utils.converters.DateConverter
    275275   :members:
    276276   :inherited-members:
    … …  
    294294:class:`TextConverter` instance:
    295295
    296     >>> from waeup.sirp.utils.converters import TextConverter
     296    >>> from waeup.kofa.utils.converters import TextConverter
    297297    >>> converter = TextConverter(field)
    298298
    299299Or we can just grab a registered adapter:
    300300
    301     >>> from waeup.sirp.interfaces import ISchemaTypeConverter
     301    >>> from waeup.kofa.interfaces import ISchemaTypeConverter
    302302    >>> converter = ISchemaTypeConverter(field)
    303303
    … …  
    305305
    306306    >>> converter
    307     <waeup.sirp.utils.converters.TextConverter object at 0x...>
     307    <waeup.kofa.utils.converters.TextConverter object at 0x...>
    308308
    309309Now we can convert strings to this type:
    … …  
    382382:class:`BoolConverter` instance:
    383383
    384     >>> from waeup.sirp.utils.converters import BoolConverter
     384    >>> from waeup.kofa.utils.converters import BoolConverter
    385385    >>> converter = BoolConverter(field)
    386386
    387387Or we can just grab a registered adapter:
    388388
    389     >>> from waeup.sirp.interfaces import ISchemaTypeConverter
     389    >>> from waeup.kofa.interfaces import ISchemaTypeConverter
    390390    >>> converter = ISchemaTypeConverter(field)
    391391
    … …  
    393393
    394394    >>> converter
    395     <waeup.sirp.utils.converters.BoolConverter object at 0x...>
     395    <waeup.kofa.utils.converters.BoolConverter object at 0x...>
    396396
    397397Now we can convert strings to this type:
    … …  
    494494:class:`IntConverter` instance:
    495495
    496     >>> from waeup.sirp.utils.converters import IntConverter
     496    >>> from waeup.kofa.utils.converters import IntConverter
    497497    >>> converter = IntConverter(field)
    498498
    499499Or we can just grab a registered adapter:
    500500
    501     >>> from waeup.sirp.interfaces import ISchemaTypeConverter
     501    >>> from waeup.kofa.interfaces import ISchemaTypeConverter
    502502    >>> converter = ISchemaTypeConverter(field)
    503503
    … …  
    505505
    506506    >>> converter
    507     <waeup.sirp.utils.converters.IntConverter object at 0x...>
     507    <waeup.kofa.utils.converters.IntConverter object at 0x...>
    508508
    509509Now we can convert strings to this type:
    … …  
    597597:class:`ChoiceConverter` instance:
    598598
    599     >>> from waeup.sirp.utils.converters import ChoiceConverter
     599    >>> from waeup.kofa.utils.converters import ChoiceConverter
    600600    >>> converter = ChoiceConverter(field)
    601601
    602602Or we can just grab a registered adapter:
    603603
    604     >>> from waeup.sirp.interfaces import ISchemaTypeConverter
     604    >>> from waeup.kofa.interfaces import ISchemaTypeConverter
    605605    >>> converter = ISchemaTypeConverter(field)
    606606
    … …  
    608608
    609609    >>> converter
    610     <waeup.sirp.utils.converters.ChoiceConverter object at 0x...>
     610    <waeup.kofa.utils.converters.ChoiceConverter object at 0x...>
    611611
    612612Now we can convert strings to this type:
    … …  
    672672    '1'
    673673
    674     >>> from waeup.sirp.interfaces import SimpleSIRPVocabulary
     674    >>> from waeup.kofa.interfaces import SimpleKOFAVocabulary
    675675    >>> field = Choice(
    676676    ...   title = u'Favourite Dish',
    677677    ...   default = 0,
    678     ...   vocabulary = SimpleSIRPVocabulary(
     678    ...   vocabulary = SimpleKOFAVocabulary(
    679679    ...        ('N/A', 0), ('Pizza', 1),
    680680    ...        ('Cake', 2), ('Muffins', 3)),
    … …  
    730730
    731731We get a converter for this field in the usual way. The
    732 :meth:`waeup.sirp.utils.converters.fromString()` method will return one of
     732:meth:`waeup.kofa.utils.converters.fromString()` method will return one of
    733733the objects if we feed it with ``'Wilma'`` or ``'Fred'``:
    734734
    … …  
    763763:class:`IntConverter` instance:
    764764
    765     >>> from waeup.sirp.utils.converters import DateConverter
     765    >>> from waeup.kofa.utils.converters import DateConverter
    766766    >>> converter = DateConverter(field)
    767767
    768768Or we can just grab a registered adapter:
    769769
    770     >>> from waeup.sirp.interfaces import ISchemaTypeConverter
     770    >>> from waeup.kofa.interfaces import ISchemaTypeConverter
    771771    >>> converter = ISchemaTypeConverter(field)
    772772
    … …  
    774774
    775775    >>> converter
    776     <waeup.sirp.utils.converters.DateConverter object at 0x...>
     776    <waeup.kofa.utils.converters.DateConverter object at 0x...>
    777777
    778778Now we can convert strings to this type:

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/helpers.py

    r7359 r7811  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """General helper functions for SIRP.
     18"""General helper functions for KOFA.
    1919"""
    2020import os
    … …  
    151151    instances of certain classes when called.
    152152
    153     In :mod:`waeup.sirp` we use factories extensively for
     153    In :mod:`waeup.kofa` we use factories extensively for
    154154    batching. While processing a batch some importer looks up a
    155155    factory to create real-world instances that then get filled with
    … …  
    163163
    164164       >>> import grok
    165        >>> from waeup.sirp.utils.helpers import FactoryBase
     165       >>> from waeup.kofa.utils.helpers import FactoryBase
    166166       >>> class MyObject(object):
    167167       ...   # Some class we want to get instances of.
    … …  
    169169       >>> class MyObjectFactory(FactoryBase):
    170170       ...   # This is the factory for MyObject instances
    171        ...   grok.name(u'waeup.sirp.factory.MyObject')
     171       ...   grok.name(u'waeup.kofa.factory.MyObject')
    172172       ...   factory = MyObject
    173173
    … …  
    176176    called. The given name must even be unique amongst all utilities
    177177    registered during runtime. While you can pick any name you like
    178     you might want to prepend ``waeup.sirp.factory.`` to the name
     178    you might want to prepend ``waeup.kofa.factory.`` to the name
    179179    string to make sure it does not clash with names of other
    180180    utilities one day.
    … …  
    183183    freshly defined factory. This executes all the component
    184184    registration stuff we don't want to do ourselves. In daily use
    185     this is done automatically on startup of a :mod:`waeup.sirp`
     185    this is done automatically on startup of a :mod:`waeup.kofa`
    186186    system.
    187187
    188        >>> grok.testing.grok('waeup.sirp.utils.helpers')
     188       >>> grok.testing.grok('waeup.kofa.utils.helpers')
    189189       >>> grok.testing.grok_component(
    190190       ...    'MyObjectFactory', MyObjectFactory
    … …  
    197197
    198198       >>> from zope.component import createObject
    199        >>> obj = createObject('waeup.sirp.factory.MyObject')
     199       >>> obj = createObject('waeup.kofa.factory.MyObject')
    200200       >>> isinstance(obj, MyObject)
    201201       True
    … …  
    207207       >>> from zope.component.interfaces import IFactory
    208208       >>> factory = getUtility(
    209        ...   IFactory, name='waeup.sirp.factory.MyObject'
     209       ...   IFactory, name='waeup.kofa.factory.MyObject'
    210210       ...   )
    211211       >>> isinstance(factory, MyObjectFactory)
    … …  
    251251    HTML code:
    252252
    253         >>> from waeup.sirp.utils.helpers import ReST2HTML
     253        >>> from waeup.kofa.utils.helpers import ReST2HTML
    254254        >>> source = '''
    255255        ... Headline

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/helpers.txt

    r7496 r7811  
    1 :mod:`waeup.sirp.utils.helpers` -- Helpers for SIRP
     1:mod:`waeup.kofa.utils.helpers` -- Helpers for KOFA
    22***************************************************
    33
    4 .. module:: waeup.sirp.utils.helpers
    5 
    6 Helper functions for SIRP.
     4.. module:: waeup.kofa.utils.helpers
     5
     6Helper functions for KOFA.
    77
    88.. :doctest:
    … …  
    2121     >>> os.chdir(new_location)
    2222
    23      >>> from waeup.sirp.utils.helpers import remove_file_or_directory
     23     >>> from waeup.kofa.utils.helpers import remove_file_or_directory
    2424     >>> open('blah', 'wb').write('nonsense')
    2525     >>> 'blah' in os.listdir('.')
    … …  
    7272     >>> open(os.path.join('src', 'blah'), 'wb').write('nonsense')
    7373
    74      >>> from waeup.sirp.utils.helpers import copy_filesystem_tree
     74     >>> from waeup.kofa.utils.helpers import copy_filesystem_tree
    7575     >>> result = copy_filesystem_tree('src', 'dst')
    7676
    … …  
    179179   returned with all preceeding/following stuff stripped:
    180180
    181      >>> from waeup.sirp.utils.helpers import get_inner_HTML_part
     181     >>> from waeup.kofa.utils.helpers import get_inner_HTML_part
    182182     >>> print get_inner_HTML_part("""<html>
    183183     ... <head>

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/importexport.py

    r7321 r7811  
    2222from cStringIO import StringIO
    2323from zope.interface import Interface
    24 from waeup.sirp.interfaces import (ISIRPObject, ISIRPExporter,
    25                                    ISIRPXMLExporter, ISIRPXMLImporter)
     24from waeup.kofa.interfaces import (IKOFAObject, IKOFAExporter,
     25                                   IKOFAXMLExporter, IKOFAXMLImporter)
    2626
    2727def readFile(f):
    … …  
    4040
    4141class Exporter(grok.Adapter):
    42     """Export a SIRP object as pickle.
     42    """Export a KOFA object as pickle.
    4343
    4444    This all-purpose exporter exports attributes defined in schemata
    4545    and contained objects (if the exported thing is a container).
    4646    """
    47     grok.context(ISIRPObject)
    48     grok.provides(ISIRPExporter)
     47    grok.context(IKOFAObject)
     48    grok.provides(IKOFAExporter)
    4949
    5050    def __init__(self, context):
    … …  
    6161
    6262class XMLExporter(grok.Adapter):
    63     """Export a SIRP object as XML.
     63    """Export a KOFA object as XML.
    6464
    6565    This all-purpose exporter exports XML representations of pickable
    … …  
    6767    """
    6868    grok.context(Interface)
    69     grok.provides(ISIRPXMLExporter)
     69    grok.provides(IKOFAXMLExporter)
    7070
    7171    def __init__(self, context):
    7272        self.context = context
    73    
     73
    7474    def export(self, filepath=None):
    7575        pickled_obj = cPickle.dumps(self.context)
    … …  
    8484
    8585class XMLImporter(grok.Adapter):
    86     """Import a SIRP object from XML.
     86    """Import a KOFA object from XML.
    8787    """
    8888    grok.context(Interface)
    89     grok.provides(ISIRPXMLImporter)
     89    grok.provides(IKOFAXMLImporter)
    9090
    9191    def __init__(self, context):
    9292        self.context = context
    93    
     93
    9494    def doImport(self, filepath):
    9595        xml = None

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/importexport.txt

    r7321 r7811  
    66
    77.. :doctest:
    8 .. :layer: waeup.sirp.testing.SIRPUnitTestLayer
     8.. :layer: waeup.kofa.testing.KOFAUnitTestLayer
    99
    1010As imports and exports of data are a cruical point when doing updates
    … …  
    6060an exporter::
    6161
    62     >>> from waeup.sirp.interfaces import ISIRPXMLExporter
    63     >>> exporter = ISIRPXMLExporter(mycave)
     62    >>> from waeup.kofa.interfaces import IKOFAXMLExporter
     63    >>> exporter = IKOFAXMLExporter(mycave)
    6464    >>> exporter
    65     <waeup.sirp.utils.importexport.XMLExporter object at 0x...>
     65    <waeup.kofa.utils.importexport.XMLExporter object at 0x...>
    6666
    6767All exporters provide an ``export(<obj>)`` method::
    … …  
    101101Now we create an importer for that object:
    102102
    103     >>> from waeup.sirp.interfaces import ISIRPXMLImporter
    104     >>> importer = ISIRPXMLImporter(mycave)
     103    >>> from waeup.kofa.interfaces import IKOFAXMLImporter
     104    >>> importer = IKOFAXMLImporter(mycave)
    105105
    106106Importing from filenames

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/logger.py

    r7651 r7811  
    1919Convenience stuff for logging.
    2020
    21 Main component of :mod:`waeup.sirp.utils.logging` is a mix-in class
    22 :class:`waeup.sirp.utils.logging.Logger`. Classes derived (also) from
     21Main component of :mod:`waeup.kofa.utils.logging` is a mix-in class
     22:class:`waeup.kofa.utils.logging.Logger`. Classes derived (also) from
    2323that mix-in provide a `logger` attribute that returns a regular Python
    2424logger logging to a rotating log file stored in the datacenter storage
    … …  
    3030The `logger_name` tells under which name the logger should be
    3131registered Python-wise. This is usually a dotted name string like
    32 ``waeup.sirp.${sitename}.mycomponent`` which should be unique. If you
     32``waeup.kofa.${sitename}.mycomponent`` which should be unique. If you
    3333pick a name already used by another component, trouble is ahead. The
    3434``${sitename}`` chunk of the name can be set literally like this. The
    … …  
    4646your `logger_name` and `logger_filename` attribute and off you go::
    4747
    48   from waeup.sirp.utils.logger import Logger
     48  from waeup.kofa.utils.logger import Logger
    4949
    5050  class MyComponent(object, Logger):
    5151      # Yes that's a complete working class
    52       logger_name = 'waeup.sirp.${sitename}.mycomponent
     52      logger_name = 'waeup.kofa.${sitename}.mycomponent
    5353      logger_filename = 'mycomponent.log'
    5454
    … …  
    6767
    6868The datacenter and its storage are created automatically when you
    69 create a :class:`waeup.sirp.app.University`. This also means that
     69create a :class:`waeup.kofa.app.University`. This also means that
    7070logging with the `Logger` mix-in will work only inside so-called sites
    7171(`University` instances put into ZODB are such `sites`).
    … …  
    8080from zope.component import queryUtility
    8181from zope.interface import Interface, Attribute, implements
    82 from waeup.sirp.interfaces import (
     82from waeup.kofa.interfaces import (
    8383    IDataCenter, IDataCenterStorageMovedEvent, ILoggerCollector)
    84 from waeup.sirp.utils.helpers import get_current_principal
     84from waeup.kofa.utils.helpers import get_current_principal
    8585
    8686#: Default logfile size (5 KB)
    … …  
    152152
    153153    #: The Python logger name used when
    154     #: logging. ``'waeup.sirp.${sitename}'`` by default. You can use the
     154    #: logging. ``'waeup.kofa.${sitename}'`` by default. You can use the
    155155    #: ``${sitename}`` placeholder in that string, which will be
    156156    #: replaced by the actual used site name.
    157     logger_name = 'waeup.sirp.${sitename}'
     157    logger_name = 'waeup.kofa.${sitename}'
    158158    implements(ILogger)
    159159
    … …  
    378378    return
    379379
    380 from waeup.sirp.interfaces import IUniversity
     380from waeup.kofa.interfaces import IUniversity
    381381@grok.subscribe(IUniversity, grok.IObjectRemovedEvent)
    382382def handle_site_removed(obj, event):

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/tests/test_batching.py

    r7196 r7811  
    2727from zope.component.interfaces import IFactory
    2828from zope.interface import Interface, implements
    29 from waeup.sirp.app import University
    30 from waeup.sirp.testing import FunctionalLayer, FunctionalTestCase
     29from waeup.kofa.app import University
     30from waeup.kofa.testing import FunctionalLayer, FunctionalTestCase
    3131
    3232optionflags = (
    … …  
    7171stoneville = dict
    7272
    73 from waeup.sirp.utils.batching import BatchProcessor
     73from waeup.kofa.utils.batching import BatchProcessor
    7474class CaveProcessor(BatchProcessor):
    7575    util_name = 'caveprocessor'

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/tests/test_converters.py

    r7649 r7811  
    3131    Interface, implements, invariant, Invalid, implementedBy)
    3232
    33 from waeup.sirp.app import University
    34 from waeup.sirp.testing import FunctionalLayer, FunctionalTestCase
    35 from waeup.sirp.university import Faculty
    36 from waeup.sirp.utils.converters import IObjectConverter
    37 from waeup.sirp.utils.helpers import attrs_to_fields
    38 from waeup.sirp.interfaces import SimpleSIRPVocabulary
    39 
    40 colors = SimpleSIRPVocabulary(
     33from waeup.kofa.app import University
     34from waeup.kofa.testing import FunctionalLayer, FunctionalTestCase
     35from waeup.kofa.university import Faculty
     36from waeup.kofa.utils.converters import IObjectConverter
     37from waeup.kofa.utils.helpers import attrs_to_fields
     38from waeup.kofa.interfaces import SimpleKOFAVocabulary
     39
     40colors = SimpleKOFAVocabulary(
    4141    ('Red', u'red'),
    4242    ('Green', u'green'),
    4343    ('Blue', u'blue'),
    4444    )
    45 car_nums = SimpleSIRPVocabulary(
     45car_nums = SimpleKOFAVocabulary(
    4646    ('None', 0),
    4747    ('One', 1),

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/tests/test_doctests.py

    r7196 r7811  
    1818"""Register doctests from utils subpackage.
    1919"""
    20 from waeup.sirp.testing import get_doctest_suite
     20from waeup.kofa.testing import get_doctest_suite
    2121
    2222def test_suite():

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/tests/test_helpers.py

    r7196 r7811  
    2727from zope.security.testing import Principal, Participation
    2828from zope.security.management import newInteraction, endInteraction
    29 from waeup.sirp.utils import helpers
     29from waeup.kofa.utils import helpers
    3030
    3131from zope.interface import Interface, implements

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/tests/test_logger.py

    r7651 r7811  
    1717##
    1818
    19 # Tests for waeup.sirp.utils.logger
     19# Tests for waeup.kofa.utils.logger
    2020import logging
    2121import os
    … …  
    2525from zope.component.hooks import setSite, clearSite
    2626from zope.interface.verify import verifyClass, verifyObject
    27 from waeup.sirp.app import University
    28 from waeup.sirp.testing import FunctionalLayer, FunctionalTestCase
    29 
    30 from waeup.sirp.utils.logger import (
     27from waeup.kofa.app import University
     28from waeup.kofa.testing import FunctionalLayer, FunctionalTestCase
     29
     30from waeup.kofa.utils.logger import (
    3131    Logger, MAX_BYTES, BACKUP_COUNT, ILoggerCollector, LoggerCollector,
    3232    ILogger)

  • main/waeup.kofa/trunk/src/waeup/kofa/utils/utils.py

    r7744 r7811  
    1616## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    1717##
    18 """General helper utilities for SIRP.
     18"""General helper utilities for KOFA.
    1919"""
    2020import os
    … …  
    2323from zope.i18n import translate
    2424from random import SystemRandom as r
    25 from waeup.sirp.interfaces import ISIRPUtils
    26 from waeup.sirp.interfaces import MessageFactory as _
    27 from waeup.sirp.smtp import send_mail as send_mail_internally
     25from waeup.kofa.interfaces import IKOFAUtils
     26from waeup.kofa.interfaces import MessageFactory as _
     27from waeup.kofa.smtp import send_mail as send_mail_internally
    2828
    2929def send_mail(from_name,from_addr,rcpt_name,rcpt_addr,subject,body,config):
    30     """Wrapper for the real SMTP functionality in :mod:`waeup.sirp.smtp`.
     30    """Wrapper for the real SMTP functionality in :mod:`waeup.kofa.smtp`.
    3131
    3232    Merely here to stay compatible with lots of calls to this place.
    … …  
    3737    return True
    3838
    39 class SIRPUtils(grok.GlobalUtility):
     39class KOFAUtils(grok.GlobalUtility):
    4040    """A collection of parameters and methods subject to customization.
    4141    """
    42     grok.implements(ISIRPUtils)
     42    grok.implements(IKOFAUtils)
    4343    # This the only place where we define the portal language
    4444    # which is used for the translation of system messages
    … …  
    131131            'd':portal,
    132132            'e':body})
    133         body = translate(text, 'waeup.sirp',
     133        body = translate(text, 'waeup.kofa',
    134134            target_language=self.PORTAL_LANGUAGE)
    135135        return send_mail(
    … …  
    161161        Returns True or False to indicate successful operation.
    162162        """
    163         subject = 'Your SIRP credentials'
     163        subject = 'Your KOFA credentials'
    164164        text = _(u"""Dear ${a},
    165165
    … …  
    193193            'f':login_url})
    194194
    195         body = translate(text, 'waeup.sirp',
     195        body = translate(text, 'waeup.kofa',
    196196            target_language=self.PORTAL_LANGUAGE)
    197197        return send_mail(
Note: See TracChangeset for help on using the changeset viewer.