semvec/pypi-packages huggingface dataset:
django-slds-crispyforms 0.1.0
Django Crispy Forms template overrides for rendering forms using the Salesforce Lightning Design System
License: BSD
Keywords: django-slds-crispyforms

=============================
django_slds_crispyforms
=============================

.. image:: https://badge.fury.io/py/django-slds-crispyforms.png
    :target: https://badge.fury.io/py/django-slds-crispyforms

.. image:: https://travis-ci.org/jlantz/django-slds-crispyforms.png?branch=master
    :target: https://travis-ci.org/jlantz/django-slds-crispyforms

Django Crispy Forms template overrides for rendering forms using the Salesforce Lightning Design System

Documentation
-------------

The full documentation is at https://django-slds-crispyforms.readthedocs.org.

Quickstart
----------

Install django_slds_crispyforms::

    pip install django-slds-crispyforms

Then use it in a project::

    import django_slds_crispyforms

Features
--------

* TODO

Running Tests
--------------

Does the code actually work?

::

    source <YOURVIRTUALENV>/bin/activate
    (myenv) $ pip install -r requirements_test.txt
    (myenv) $ python runtests.py

Credits
---------

Tools used in rendering this package:

*  Cookiecutter_
*  `cookiecutter-djangopackage`_

.. _Cookiecutter: https://github.com/audreyr/cookiecutter
.. _`cookiecutter-djangopackage`: https://github.com/pydanny/cookiecutter-djangopackage




History
-------

0.1.0 (2016-09-16)
++++++++++++++++++

* First release on PyPI.
tokenizertools 1.0
Implements lexical analyzers as iterators yielding tokens.
License: BSD

==============
tokenizertools
==============

Text file tokenizers that support multiple start states
and lexical tracking implemented as standard Python iterators.

Classes provided:

* Tokenizer -- Base class.
* RegexTokenizer -- Python re-based tokenizer.
* TokenizeAhead -- A look-ahead iterator that can wrap any tokenizer.

Overview
--------

The class ``RegexTokenizer`` implements a tokenizer using the ``re`` 
module to recognize tokens in the input stream.
Tokens and actions are defined by rules.
The tokenizer calls user action functions associated with each rule.
In most cases, the user action function can simply be a ``@classmethod``
constructor of a user-provided token class.

Each rule is specified as a tuple.
The first element of the tuple is a regular expression that will
be compiled by ``re`` and used to match a token.
The second element of the tuple is a user-provided callable that 
will be passed
the recognized text, along with the current lexical position.

In this example, the user class ``Token`` implements constructors
as ``@classmethod`` functions, and these serve as the callables in
each lexical rule.

Rules are specified in the class variable ``spec``, which is a
list of rules. ::

  import tokenizertools as tt
  class MyTokenizer(tt.RegexTokenizer):
      spec = [
          (r'[a-zA-Z][a-zA-Z0-9_]*',Token.type_ident), # idents and keywords
          (r'[0-9]+\.[0-9]+',Token.type_float), # floats
          (r'[0-9]+', Token.type_int), # ints
          (r'\s*',None), # ignore white space
      ]

Nothing else needs to be defined.  All methods are inherited.
Instantiate a lexer and commence parsing.
The specification rules are compiled and cached on creation
of the first instance.::

  tokenizer = MyTokenizer()
  with open('foo.bar') as f:
      token_stream = Lookahead(tokenizer.lex(f, f.name))
      compiled_stuff = my_parser.parse(token_stream)

===================
tokenizertools news
===================

Release history.

15-Sept-2016
------------

1.0 Time to put some mileage on it.

Clean ups, PEP8-ification. 
Improved exception handling for bad ``begin()`` state.

16-June-2014
------------

0.1a Initial alpha.
lookaheadtools 1.0
Make any iterator a look-ahead iterator. Provides specialized look-ahead iterators for text files.
License: BSD

==============
lookaheadtools
==============

The lookaheadtools module extends generic iterators to support look-ahead,
and also provides some convenient look-ahead iterators that are useful for
processing text files.

Lookahead is implemented by extending iterators with support for __getitem__().
For example: ::

  import lookaheadtools as la
  looker = la.lookahead(iter([0,1,2,3,4]))
  assert looker[3] == 3
  assert looker[0] == 0
  assert looker[1000] == None
  assert looker[0:9:2] == [0,2,4]
  assert next(looker) == 0
  assert looker[0] == 1

As seen in the example, myLookaheadIter[0] returns the value that will 
be returned by next(myLookaheadIter) but without consuming it.
Arbitrary lookahead distance is supported.  Attempts to lookahead 
past the end of the iterator will return None.  The look-ahead index 
can be any slice with positive indices.

Classes Provided
----------------

Lookahead(object) -- Convert any iterator into a look-ahead iterator.

LinesOf(object) -- Iterate line-by-line over a string, emulating text file
iteration.

Lexpos (a named tuple) -- Convenience class for capturing lexical 
tracking information.

FileLookahead(Lookahead) -- FileLookahead() is a specialization of the
Lookahead() class that iterates by characters over a text file with 
full lexical position tracking.

LexAhead(FileLookahead) -- LexAhead() is a specialization of 
FileLookahead() that includes some simple tokenizing utilities, 
stopping short of being a full tokenizer.  See tokenizertools 
for a module that builds a tokenizer on top of LexAhead().


===================
lookaheadtools news
===================

Update history.

15-Sep-2016
------------
1.0 release.  
Tweaked setup.py to make it more robust.

16-June-2014
------------
0.2b release.