Metadata-Version: 2.1
Name: funkybob
Version: 2018.5.1
Summary: UNKNOWN
Home-page: https://github.com/andreacorbellini/funkybob
Author: Andrea Corbellini
Author-email: corbellini.andrea@gmail.com
License: MIT License
Description: # Random name generator in Python
        
        funkybob is a Python library for generating Docker-style random names,
        like these:
        
            ecstatic_ritchie, kind_beaver, sharp_heisenberg, angry_nightingale, ...
        
        funkybob supports generating names preceeded by an arbirary number of
        adjectives, in order to increase the number of unique names that can
        be generated:
        
            Random names with no adjectives:
                swirles, khorana, blackwell, ...
        
            Random names preceeded by an adjective:
                ecstatic_ritchie, kind_beaver, sharp_heisenberg, ...
        
            Random names preceeded by two adjectives:
                admiring_dazzling_noether, thirsty_wonderful_agnesi, silly_wizardly_feynman, ...
        
            Random names preceeded by three adjectives:
                cranky_goofy_hopeful_wright, competent_jolly_suspicious_kare, cocky_competent_gifted_yalow, ...
        
        When using more than one adjective, funkybob ensures that two names with the
        same set of adjectives cannot occur, even if the order is different. So, for
        example, if the name `inspiring_stupefied_payne` was generated, then you can
        be sure that the name `stupefied_inspiring_payne` won't be generated later.
        This makes names much more easier to distinguish and less likely to generate
        confusion.
        
        
        ## Generators
        
        funkybob ships three different name generators:
        
        * **SimpleNameGenerator**: this provides a deterministic sequence of names --
          no randomness involved. This will return duplicate names once all
          combinations have been yielded. Useful if all you care about is performance.
        
        * **RandomNameGenerator**: returns randomly generated names. It may return
          duplicate names at any point.
        
        * **UniqueRandomNameGenerator**: returns randomly generated names, but unlike
          RandomNameGenerator, no duplicates are returned. Unlike the other two
          generators, this one has a limited size and will stop yielding values once
          all unique names have been returned.
        
        This table sumarizes the features of all three generators:
        
        | Generator                 | Infinite | Random | Duplicates |
        |---------------------------|----------|--------|------------|
        | SimpleNameGenerator       | Yes      | No     | Yes        |
        | RandomNameGenerator       | Yes      | Yes    | Yes        |
        | UniqueRandomNameGenerator | No       | Yes    | No         |
        
        
        ## Usage
        
        All three generators are iterables, which means that you can simply use
        `iter()` and `next()` on them in order to retrieve names:
        
        ```python
        >>> import funkybob
        >>> generator = funkybob.RandomNameGenerator()
        >>> it = iter(generator)
        >>> next(it)
        'practical_hoover'
        >>> next(it)
        'stupefied_ramanujan'
        >>> next(it)
        'zealous_aryabhata'
        ```
        
        You can pass the `members` and `separator` parameters to change the number of
        adjectives or the formatting of names:
        
        ```python
        >>> # This will generate names with 3 members (2 adjectives + 1 last name),
        >>> # separated by a colon
        >>> generator = funkybob.RandomNameGenerator(members=3, separator=':')
        >>> it = iter(generator)
        >>> next(it)
        'friendly:hopeful:neumann'
        >>> next(it)
        'admiring:trusting:montalcini'
        >>> next(it)
        'practical:suspicious:blackwell'
        ```
        
        Generators have an `unique_count` attribute that you can use to check
        the number of unique names that can be generated:
        
        ```python
        >>> generator.unique_count
        740094
        ```
        
        
        ### UniqueRandomNameGenerator
        
        In addition to all of the above, UniqueRandomNameGenerator privides a
        [sequence](https://docs.python.org/3/glossary.html#term-sequence)-like
        interfance, which means, for example, that you can use indexing or the
        `len()` method (which is the same as accessing the `unique_count`
        attribute):
        
        ```python
        >>> generator = funkybob.UniqueRandomNameGenerator()
        >>> generator[0]
        'xenodochial_yalow'
        >>> generator[1]
        'kind_mccarthy'
        >>> generator[2]
        'happy_hawking'
        >>> len(generator)
        16089
        ```
        
        You can increase the number of `members` in order to increase the size,
        at the expense of having longer names.
        
        UniqueRandomNameGenerator also supports an additional parameter: `seed`.
        This can be used to initialize the pseudo-random generator. If you pass
        always the same value, the same sequence of names will be generated. This
        can be useful in tests when you need predictable names.
        
Platform: UNKNOWN
Description-Content-Type: text/markdown
