Metadata-Version: 1.1
Name: benry
Version: 0.1.0
Summary: Experimental utilities for Python
Home-page: https://pypi.python.org/pypi/benry
Author: makoto kuwata
Author-email: kwa@kuwata-lab.com
License: MIT License
Download-URL: https://pypi.python.org/packages/source/b/benry/benry-0.1.0.tar.gz
Description: =====
        benry
        =====
        
        $Release: 0.1.0 $
        
        
        Useful tools for Python.
        
        
        benry.rexp
        ==========
        
        
        rx()
        ----
        
        ``benry.rexp.rx()`` is a short cut to ``re.compile()``. ::
        
            from benry.rexp import rx
            
            ## comping -- same as re.compile(r'pat') or re.compile(r'pat', rx.I|rx.S)
            regexp = rx(r'pat')
            regexp = rx(r'pat', rx.I|rx.S)
            
            ## matching -- same as re.compile(r'pat').search(string)
            m = rx(r'pat').search(string)
            
            ## replacing -- same as re.compile(r'pat').sub('repl', string, count=1)
            rx(r'pat').sub('repl', string, count=1)
        
        You don't need to use ``re.xxxx()`` functions because ``rx().xxxx()`` does same things,
        and has more features. ::
        
            ## For example you can't specify starting/ending position with re.match().
            re.match(r'pat', string, re.I)
        
            ## But you can specify them with rx().match().
            rx(r'pat', re.I).match(string, start_pos, end_pos)
        
        
        rx.compile()
        ------------
        
        ``rx.compile()`` (or ``benry.rexp.compile()``) is similar to ``re.compile()``,
        but the former doesn't cache compiled pattern while the latter caches it.
        
        This is very useful when there are a lot of regexp pattern and they are
        no need to cache into library. ::
        
            mappings = [
                (r'^/posts$',                      'app.PostsPage'),
                (r'^/posts/new$',                  'app.PostCreatePage'),
                (r'^/posts/(?P<id>\d+)$',          'app.PostPage'),
                (r'^/posts/(?P<id>\d+)/edit$',     'app.PostUpdatePage'),
                (r'^/posts/(?P<id>\d+)/comments$', 'app.PostCommentsPage'),
            ]
        
            ## no need to cache patterns, so calls rx.compile() instead of re.compile()
            from benry.rexp import rx   # or: import compile
            compiled_mappings = [ (rx.compile(pat), cls) for pat, cls in mappings ]
        
        
        rx.matching()
        -------------
        
        ``rx.matching()`` (or ``benry.rexp.matching()``) is a utility class to help you
        when matching to a lot of patterns.
        
        Without ``rx.matching()``::
        
            import re
        
            m = re.match(r'^(\d\d\d\d)-(\d\d)-(\d\d)$', string)
            if m:
                Y, M, D = m.groups()
            else:
                m = re.match(r'^(\d\d)/(\d\d)/(\d\d\d\d)$', string)
                if m:
                    M, D, Y = m.groups()
                else:
                    m = re.match(r'^(\d\d\d\d)/(\d\d)/(\d\d)$', string)
                    if m:
                        Y, M, D = m.groups()
        
        With ``rx.matching()``::
        
            from benry.rexp import rx
        
            m = rx.matching(string)
            if   m.match(r'^(\d\d\d\d)-(\d\d)-(\d\d)$'):
                Y, M, D = m.groups()     # or Y, M, D = m
            elif m.match(r'^(\d\d)/(\d\d)/(\d\d\d\d)$'):
                M, D, Y = m.groups()     # or M, D, Y = m
            elif m.match(r'^(\d\d\d\d)/(\d\d)/(\d\d)$'):
                Y, M, D = m.groups()     # or Y, M, D = m
        
        You can get ``SRE_Match`` object by ``m.matched``. ::
        
            m = rx.matching(string)
            if m.match(r'pat'):
                print(m.matched.pos)
                print(m.matched.endpos)
        
        
        type
        ----
        
        ``rx.type`` represents class of regular expression. ::
        
            import re
            from benry.rexp import rx
        
            assert rx.type is type(re.compile('x'))
        
        
        
        benry.date_time
        ===============
        
        
        class UTCDateTime
        -----------------
        
        ``UTCDdateTime`` is a subclass of ``datetime.datetime`` representing UTC offset. ::
        
            from benry.date_time import UTCDateTime
        
            print(UTCDateTime.offset_minutes)      #=> 0
            print(UTCDateTime.offset_timedelta)    #=> timedelta(seconds=0)
            print(UTCDateTime.is_utc)              #=> True
            print(UTCDateTime.is_local)            #=> False
        
            ## almost same as datetime.utcnow(), except returning UTCDateTime object.
            utc_dt = UTCDateTime.now()
        
            print(utc_dt.to_utc())                 # returns self.
            print(utc_dt.to_local())               # returns LocalDateTime object.
        
        
        class LocalDateTime
        -------------------
        
        ``UTCDdateTime`` is a subclass of ``datetime.datetime`` representing local time.
        This class calculates offset between local time and UTC time. ::
        
            from benry.date_time import LocalDateTime
        
            print(LocalDateTime.offset_minutes)    #=> 9*60  (ex: JST timezone)
            print(LocalDateTime.offset_timedelta)  #=> timedelta(seconds=9*60*60)
            print(LocalDateTime.is_utc)            #=> False
            print(LocalDateTime.is_local)          #=> True
        
            ## almost same as datetime.now(), except returning LocalDateTime object.
            local_dt = LocalDateTime.now()
        
            print(local_dt.to_utc())               # returns UTCDateTime object.
            print(local_dt.to_local())             # returns self.
        
Platform: any
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Utilities
