Flask-Seeder-1.2.0/0000775000372000037200000000000013765161112014624 5ustar travistravis00000000000000Flask-Seeder-1.2.0/MANIFEST.in0000664000372000037200000000017313765161026016367 0ustar travistravis00000000000000graft flask_seeder/data/* graft tests include .coveragerc include tox.ini include .pylintrc global-exclude */__pycache__/* Flask-Seeder-1.2.0/PKG-INFO0000664000372000037200000001552613765161112015732 0ustar travistravis00000000000000Metadata-Version: 2.1 Name: Flask-Seeder Version: 1.2.0 Summary: Flask extension to seed database through scripts Home-page: https://github.com/diddi-/flask-seeder Author: Diddi Oskarsson Author-email: diddi@diddi.se License: MIT Description: # Flask-Seeder [![Build Status](https://travis-ci.org/diddi-/flask-seeder.svg?branch=master)](https://travis-ci.org/diddi-/flask-seeder) [![Coverage Status](https://coveralls.io/repos/github/diddi-/flask-seeder/badge.svg?branch=master)](https://coveralls.io/github/diddi-/flask-seeder?branch=master) Flask-Seeder is a Flask extension to help with seeding database with initial data, for example when deploying an application for the first time. This extensions primary focus is to help populating data once, for example in a demo application where the database might get wiped over and over but you still want users to have some basic data to play around with. # Installation ``` pip install Flask-Seeder ``` This will install the Flask-Seeder extension and add a `flask seed` subcommand, check it out to see what arguments are supported! # Seeders Flask-Seeder provides a base class `Seeder` that holds a database handle. By subclassing `Seeder` and implementing a `run()` method you get access to the database handle object and can start seeding the database with data. All seeders must be somewhere in the `seeds/` directory and inherit from `Seeder` or else they won't be detected. When all seeders have completed (successfully or not), Flask-Seeder will by default commit all changes to the database. This behaviour can be overridden with `--no-commit` or setting environment variable `FLASK_SEEDER_AUTOCOMMIT=0`. ## Run Order When splitting seeders across multiple classes and files, order of operations is determined by two factors. First the seeders are grouped by `priority` (lower priority will be run first), all seeders with the same priority are then ordered by class name. See example below for setting priority on a seeder. ```python from flask_seeder import Seeder class DemoSeeder(Seeder): def __init__(self, db=None): super().__init__(db=db) self.priority = 10 def run(self): ... ``` # Faker and Generators Flask-Seeder provides a `Faker` class that controls the creation of fake objects, based on real models. By telling `Faker` how to create the objects, you can easily create many different unique objects to help when seeding the database. There are different generators that help generate values for the fake objects. Currently supported generators are: * Integer: Create a random integer between two values * UUID: Create a random UUID * Sequence: Create integers in sequence if called multiple times * Name: Create a random name from a list `data/names/names.txt` * Email: Create a random email, a combination of the random name generator and a domain from `data/domains/domains.txt` * String: String generation from a pattern Feel free to roll your own generator by subclassing `Generator` and implement a `generate()` method that return the generated value. ## String generator pattern The `String` generator takes a pattern and produces a string that matches the pattern. Currently the generator pattern is very simple and supports only a handful of operations. | Pattern | Produces | Description | Example | | --| -- | -- | -- | | [abc] | String character | Randomly select one of the provided characters | `b` | | [a-k] | String character | Randomly select one character from a range | `i` | | \c | String character | Randomly select any alpha character (a-z, A-Z) | `B` | | (one\|two) | String group | Like `[abc]` but works for strings, not just single characters | `one` | | \d | Digit | Randomly select a single digit (0-9) | `8` | | {x} | Repeater | Repeat the previous pattern `x` times | `\d{5}` | | {m,n} | Repeater | Repeat the previous pattern `x` times where `x` is anywhere between `m` and `n` | `[0-9]{2,8}` | | abc | String literal | No processing, returned as is | `abc` | Patterns can also be combined to produce more complex strings. ``` # Produces something like: abc5586oz abc[5-9]{4}\c[xyz] ``` # Example usage Examples show only relevant snippets of code **app.py:** ```python from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_seeder import FlaskSeeder def create_app(): app = Flask(__name__) db = SQLAlchemy() db.init_app(app) seeder = FlaskSeeder() seeder.init_app(app, db) return app ``` **seeds/demo.py:** ```python from flask_seeder import Seeder, Faker, generator # SQLAlchemy database model class User(Base): def __init__(self, id_num=None, name=None, age=None): self.id_num = id_num self.name = name self.age = age def __str__(self): return "ID=%d, Name=%s, Age=%d" % (self.id_num, self.name, self.age) # All seeders inherit from Seeder class DemoSeeder(Seeder): # run() will be called by Flask-Seeder def run(self): # Create a new Faker and tell it how to create User objects faker = Faker( cls=User, init={ "id_num": generator.Sequence(), "name": generator.Name(), "age": generator.Integer(start=20, end=100) } ) # Create 5 users for user in faker.create(5): print("Adding user: %s" % user) self.db.session.add(user) ``` ***Shell*** ```bash $ flask seed run Running database seeders Adding user: ID=1, Name=Fancie, Age=76 Adding user: ID=2, Name=Shela, Age=22 Adding user: ID=3, Name=Jo, Age=33 Adding user: ID=4, Name=Laureen, Age=54 Adding user: ID=5, Name=Tandy, Age=66 DemoSeeder... [OK] Committing to database! ``` Platform: UNKNOWN Classifier: Programming Language :: Python :: 3 Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Description-Content-Type: text/markdown Flask-Seeder-1.2.0/README.md0000775000372000037200000001236613765161026016122 0ustar travistravis00000000000000# Flask-Seeder [![Build Status](https://travis-ci.org/diddi-/flask-seeder.svg?branch=master)](https://travis-ci.org/diddi-/flask-seeder) [![Coverage Status](https://coveralls.io/repos/github/diddi-/flask-seeder/badge.svg?branch=master)](https://coveralls.io/github/diddi-/flask-seeder?branch=master) Flask-Seeder is a Flask extension to help with seeding database with initial data, for example when deploying an application for the first time. This extensions primary focus is to help populating data once, for example in a demo application where the database might get wiped over and over but you still want users to have some basic data to play around with. # Installation ``` pip install Flask-Seeder ``` This will install the Flask-Seeder extension and add a `flask seed` subcommand, check it out to see what arguments are supported! # Seeders Flask-Seeder provides a base class `Seeder` that holds a database handle. By subclassing `Seeder` and implementing a `run()` method you get access to the database handle object and can start seeding the database with data. All seeders must be somewhere in the `seeds/` directory and inherit from `Seeder` or else they won't be detected. When all seeders have completed (successfully or not), Flask-Seeder will by default commit all changes to the database. This behaviour can be overridden with `--no-commit` or setting environment variable `FLASK_SEEDER_AUTOCOMMIT=0`. ## Run Order When splitting seeders across multiple classes and files, order of operations is determined by two factors. First the seeders are grouped by `priority` (lower priority will be run first), all seeders with the same priority are then ordered by class name. See example below for setting priority on a seeder. ```python from flask_seeder import Seeder class DemoSeeder(Seeder): def __init__(self, db=None): super().__init__(db=db) self.priority = 10 def run(self): ... ``` # Faker and Generators Flask-Seeder provides a `Faker` class that controls the creation of fake objects, based on real models. By telling `Faker` how to create the objects, you can easily create many different unique objects to help when seeding the database. There are different generators that help generate values for the fake objects. Currently supported generators are: * Integer: Create a random integer between two values * UUID: Create a random UUID * Sequence: Create integers in sequence if called multiple times * Name: Create a random name from a list `data/names/names.txt` * Email: Create a random email, a combination of the random name generator and a domain from `data/domains/domains.txt` * String: String generation from a pattern Feel free to roll your own generator by subclassing `Generator` and implement a `generate()` method that return the generated value. ## String generator pattern The `String` generator takes a pattern and produces a string that matches the pattern. Currently the generator pattern is very simple and supports only a handful of operations. | Pattern | Produces | Description | Example | | --| -- | -- | -- | | [abc] | String character | Randomly select one of the provided characters | `b` | | [a-k] | String character | Randomly select one character from a range | `i` | | \c | String character | Randomly select any alpha character (a-z, A-Z) | `B` | | (one\|two) | String group | Like `[abc]` but works for strings, not just single characters | `one` | | \d | Digit | Randomly select a single digit (0-9) | `8` | | {x} | Repeater | Repeat the previous pattern `x` times | `\d{5}` | | {m,n} | Repeater | Repeat the previous pattern `x` times where `x` is anywhere between `m` and `n` | `[0-9]{2,8}` | | abc | String literal | No processing, returned as is | `abc` | Patterns can also be combined to produce more complex strings. ``` # Produces something like: abc5586oz abc[5-9]{4}\c[xyz] ``` # Example usage Examples show only relevant snippets of code **app.py:** ```python from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_seeder import FlaskSeeder def create_app(): app = Flask(__name__) db = SQLAlchemy() db.init_app(app) seeder = FlaskSeeder() seeder.init_app(app, db) return app ``` **seeds/demo.py:** ```python from flask_seeder import Seeder, Faker, generator # SQLAlchemy database model class User(Base): def __init__(self, id_num=None, name=None, age=None): self.id_num = id_num self.name = name self.age = age def __str__(self): return "ID=%d, Name=%s, Age=%d" % (self.id_num, self.name, self.age) # All seeders inherit from Seeder class DemoSeeder(Seeder): # run() will be called by Flask-Seeder def run(self): # Create a new Faker and tell it how to create User objects faker = Faker( cls=User, init={ "id_num": generator.Sequence(), "name": generator.Name(), "age": generator.Integer(start=20, end=100) } ) # Create 5 users for user in faker.create(5): print("Adding user: %s" % user) self.db.session.add(user) ``` ***Shell*** ```bash $ flask seed run Running database seeders Adding user: ID=1, Name=Fancie, Age=76 Adding user: ID=2, Name=Shela, Age=22 Adding user: ID=3, Name=Jo, Age=33 Adding user: ID=4, Name=Laureen, Age=54 Adding user: ID=5, Name=Tandy, Age=66 DemoSeeder... [OK] Committing to database! ``` Flask-Seeder-1.2.0/tox.ini0000775000372000037200000000036313765161026016150 0ustar travistravis00000000000000[tox] envlist = py{36,37}, pylint skip_missing_interpreters = true [travis] python = 3.6: py36,pylint [testenv:pylint] deps = pylint commands = pylint flask_seeder/ [testenv] passenv = CI TRAVIS TRAVIS_* deps = pytest commands = pytest Flask-Seeder-1.2.0/.pylintrc0000664000372000037200000004216313765161026016503 0ustar travistravis00000000000000[MASTER] # A comma-separated list of package or module names from where C extensions may # be loaded. Extensions are loading into the active Python interpreter and may # run arbitrary code. extension-pkg-whitelist= # Add files or directories to the blacklist. They should be base names, not # paths. ignore=CVS # Add files or directories matching the regex patterns to the blacklist. The # regex matches against base names, not paths. ignore-patterns= # Python code to execute, usually for sys.path manipulation such as # pygtk.require(). #init-hook= # Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the # number of processors available to use. jobs=1 # Control the amount of potential inferred values when inferring a single # object. This can help the performance when dealing with large functions or # complex, nested conditions. limit-inference-results=100 # List of plugins (as comma separated values of python modules names) to load, # usually to register additional checkers. load-plugins= # Pickle collected data for later comparisons. persistent=yes # Specify a configuration file. #rcfile= # When enabled, pylint would attempt to guess common misconfiguration and emit # user-friendly hints instead of false-positive error messages. suggestion-mode=yes # Allow loading of arbitrary C extensions. Extensions are imported into the # active Python interpreter and may run arbitrary code. unsafe-load-any-extension=no [MESSAGES CONTROL] # Only show warnings with the listed confidence levels. Leave empty to show # all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED. confidence= # Disable the message, report, category or checker with the given id(s). You # can either give multiple identifiers separated by comma (,) or put this # option multiple times (only on the command line, not in the configuration # file where it should appear only once). You can also use "--disable=all" to # disable everything first and then reenable specific checks. For example, if # you want to run only the similarities checker, you can use "--disable=all # --enable=similarities". If you want to run only the classes checker, but have # no Warning level messages displayed, use "--disable=all --enable=classes # --disable=W". disable=print-statement, parameter-unpacking, unpacking-in-except, old-raise-syntax, backtick, long-suffix, old-ne-operator, old-octal-literal, import-star-module-level, non-ascii-bytes-literal, raw-checker-failed, bad-inline-option, locally-disabled, file-ignored, suppressed-message, useless-suppression, deprecated-pragma, use-symbolic-message-instead, apply-builtin, basestring-builtin, buffer-builtin, cmp-builtin, coerce-builtin, execfile-builtin, file-builtin, long-builtin, raw_input-builtin, reduce-builtin, standarderror-builtin, unicode-builtin, xrange-builtin, coerce-method, delslice-method, getslice-method, setslice-method, no-absolute-import, old-division, dict-iter-method, dict-view-method, next-method-called, metaclass-assignment, indexing-exception, raising-string, reload-builtin, oct-method, hex-method, nonzero-method, cmp-method, input-builtin, round-builtin, intern-builtin, unichr-builtin, map-builtin-not-iterating, zip-builtin-not-iterating, range-builtin-not-iterating, filter-builtin-not-iterating, using-cmp-argument, eq-without-hash, div-method, idiv-method, rdiv-method, exception-message-attribute, invalid-str-codec, sys-max-int, bad-python3-import, deprecated-string-function, deprecated-str-translate-call, deprecated-itertools-function, deprecated-types-field, next-method-defined, dict-items-not-iterating, dict-keys-not-iterating, dict-values-not-iterating, deprecated-operator-function, deprecated-urllib-function, xreadlines-attribute, deprecated-sys-function, exception-escape, comprehension-escape, raise-missing-from # Enable the message, report, category or checker with the given id(s). You can # either give multiple identifier separated by comma (,) or put this option # multiple time (only on the command line, not in the configuration file where # it should appear only once). See also the "--disable" option for examples. enable=c-extension-no-member [REPORTS] # Python expression which should return a note less than 10 (10 is the highest # note). You have access to the variables errors warning, statement which # respectively contain the number of errors / warnings messages and the total # number of statements analyzed. This is used by the global evaluation report # (RP0004). evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10) # Template used to display messages. This is a python new-style format string # used to format the message information. See doc for all details. #msg-template= # Set the output format. Available formats are text, parseable, colorized, json # and msvs (visual studio). You can also give a reporter class, e.g. # mypackage.mymodule.MyReporterClass. output-format=text # Tells whether to display a full report or only the messages. reports=no # Activate the evaluation score. score=yes [REFACTORING] # Maximum number of nested blocks for function / method body max-nested-blocks=5 # Complete name of functions that never returns. When checking for # inconsistent-return-statements if a never returning function is called then # it will be considered as an explicit return statement and no message will be # printed. never-returning-functions=sys.exit [BASIC] # Naming style matching correct argument names. argument-naming-style=snake_case # Regular expression matching correct argument names. Overrides argument- # naming-style. #argument-rgx= # Naming style matching correct attribute names. attr-naming-style=snake_case # Regular expression matching correct attribute names. Overrides attr-naming- # style. #attr-rgx= # Bad variable names which should always be refused, separated by a comma. bad-names=foo, bar, baz, toto, tutu, tata # Naming style matching correct class attribute names. class-attribute-naming-style=any # Regular expression matching correct class attribute names. Overrides class- # attribute-naming-style. #class-attribute-rgx= # Naming style matching correct class names. class-naming-style=PascalCase # Regular expression matching correct class names. Overrides class-naming- # style. #class-rgx= # Naming style matching correct constant names. const-naming-style=UPPER_CASE # Regular expression matching correct constant names. Overrides const-naming- # style. #const-rgx= # Minimum line length for functions/classes that require docstrings, shorter # ones are exempt. docstring-min-length=3 # Naming style matching correct function names. function-naming-style=snake_case # Regular expression matching correct function names. Overrides function- # naming-style. #function-rgx= # Good variable names which should always be accepted, separated by a comma. good-names=i, j, k, ex, Run, db, _ # Include a hint for the correct naming format with invalid-name. include-naming-hint=no # Naming style matching correct inline iteration names. inlinevar-naming-style=any # Regular expression matching correct inline iteration names. Overrides # inlinevar-naming-style. #inlinevar-rgx= # Naming style matching correct method names. method-naming-style=snake_case # Regular expression matching correct method names. Overrides method-naming- # style. #method-rgx= # Naming style matching correct module names. module-naming-style=snake_case # Regular expression matching correct module names. Overrides module-naming- # style. #module-rgx= # Colon-delimited sets of names that determine each other's naming style when # the name regexes allow several styles. name-group= # Regular expression which should only match function or class names that do # not require a docstring. no-docstring-rgx=^_ # List of decorators that produce properties, such as abc.abstractproperty. Add # to this list to register other decorators that produce valid properties. # These decorators are taken in consideration only for invalid-name. property-classes=abc.abstractproperty # Naming style matching correct variable names. variable-naming-style=snake_case # Regular expression matching correct variable names. Overrides variable- # naming-style. #variable-rgx= [FORMAT] # Expected format of line ending, e.g. empty (any line ending), LF or CRLF. expected-line-ending-format= # Regexp for a line that is allowed to be longer than the limit. ignore-long-lines=^\s*(# )??$ # Number of spaces of indent required inside a hanging or continued line. indent-after-paren=4 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 # tab). indent-string=' ' # Maximum number of characters on a single line. max-line-length=100 # Maximum number of lines in a module. max-module-lines=1000 # List of optional constructs for which whitespace checking is disabled. `dict- # separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}. # `trailing-comma` allows a space between comma and closing bracket: (a, ). # `empty-line` allows space-only lines. no-space-check=trailing-comma, dict-separator # Allow the body of a class to be on the same line as the declaration if body # contains single statement. single-line-class-stmt=no # Allow the body of an if to be on the same line as the test if there is no # else. single-line-if-stmt=no [LOGGING] # Format style used to check logging format string. `old` means using % # formatting, while `new` is for `{}` formatting. logging-format-style=old # Logging modules to check that the string format arguments are in logging # function parameter format. logging-modules=logging [MISCELLANEOUS] # List of note tags to take in consideration, separated by a comma. notes=FIXME, XXX, TODO [SIMILARITIES] # Ignore comments when computing similarities. ignore-comments=yes # Ignore docstrings when computing similarities. ignore-docstrings=yes # Ignore imports when computing similarities. ignore-imports=no # Minimum lines number of a similarity. min-similarity-lines=4 [SPELLING] # Limits count of emitted suggestions for spelling mistakes. max-spelling-suggestions=4 # Spelling dictionary name. Available dictionaries: none. To make it working # install python-enchant package.. spelling-dict= # List of comma separated words that should not be checked. spelling-ignore-words= # A path to a file that contains private dictionary; one word per line. spelling-private-dict-file= # Tells whether to store unknown words to indicated private dictionary in # --spelling-private-dict-file option instead of raising a message. spelling-store-unknown-words=no [STRING] # This flag controls whether the implicit-str-concat-in-sequence should # generate a warning on implicit string concatenation in sequences defined over # several lines. check-str-concat-over-line-jumps=no [TYPECHECK] # List of decorators that produce context managers, such as # contextlib.contextmanager. Add to this list to register other decorators that # produce valid context managers. contextmanager-decorators=contextlib.contextmanager # List of members which are set dynamically and missed by pylint inference # system, and so shouldn't trigger E1101 when accessed. Python regular # expressions are accepted. generated-members= # Tells whether missing members accessed in mixin class should be ignored. A # mixin class is detected if its name ends with "mixin" (case insensitive). ignore-mixin-members=yes # Tells whether to warn about missing members when the owner of the attribute # is inferred to be None. ignore-none=yes # This flag controls whether pylint should warn about no-member and similar # checks whenever an opaque object is returned when inferring. The inference # can return multiple potential results while evaluating a Python object, but # some branches might not be evaluated, which results in partial inference. In # that case, it might be useful to still emit no-member and other checks for # the rest of the inferred objects. ignore-on-opaque-inference=yes # List of class names for which member attributes should not be checked (useful # for classes with dynamically set attributes). This supports the use of # qualified names. ignored-classes=optparse.Values,thread._local,_thread._local # List of module names for which member attributes should not be checked # (useful for modules/projects where namespaces are manipulated during runtime # and thus existing member attributes cannot be deduced by static analysis. It # supports qualified module names, as well as Unix pattern matching. ignored-modules= # Show a hint with possible names when a member name was not found. The aspect # of finding the hint is based on edit distance. missing-member-hint=yes # The minimum edit distance a name should have in order to be considered a # similar match for a missing member name. missing-member-hint-distance=1 # The total number of similar names that should be taken in consideration when # showing a hint for a missing member. missing-member-max-choices=1 [VARIABLES] # List of additional names supposed to be defined in builtins. Remember that # you should avoid defining new builtins when possible. additional-builtins= # Tells whether unused global variables should be treated as a violation. allow-global-unused-variables=yes # List of strings which can identify a callback function by name. A callback # name must start or end with one of those strings. callbacks=cb_, _cb # A regular expression matching the name of dummy variables (i.e. expected to # not be used). dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_ # Argument names that match this expression will be ignored. Default to name # with leading underscore. ignored-argument-names=_.*|^ignored_|^unused_ # Tells whether we should check for unused import in __init__ files. init-import=no # List of qualified module names which can have objects that can redefine # builtins. redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io [CLASSES] # List of method names used to declare (i.e. assign) instance attributes. defining-attr-methods=__init__, __new__, setUp # List of member names, which should be excluded from the protected access # warning. exclude-protected=_asdict, _fields, _replace, _source, _make # List of valid names for the first argument in a class method. valid-classmethod-first-arg=cls # List of valid names for the first argument in a metaclass class method. valid-metaclass-classmethod-first-arg=cls [DESIGN] # Maximum number of arguments for function / method. max-args=5 # Maximum number of attributes for a class (see R0902). max-attributes=7 # Maximum number of boolean expressions in an if statement. max-bool-expr=5 # Maximum number of branch for function / method body. max-branches=12 # Maximum number of locals for function / method body. max-locals=15 # Maximum number of parents for a class (see R0901). max-parents=7 # Maximum number of public methods for a class (see R0904). max-public-methods=20 # Maximum number of return / yield for function / method body. max-returns=6 # Maximum number of statements in function / method body. max-statements=50 # Minimum number of public methods for a class (see R0903). min-public-methods=2 [IMPORTS] # Allow wildcard imports from modules that define __all__. allow-wildcard-with-all=no # Analyse import fallback blocks. This can be used to support both Python 2 and # 3 compatible code, which means that the block might have code that exists # only in one or another interpreter, leading to false positives when analysed. analyse-fallback-blocks=no # Deprecated modules which should not be used, separated by a comma. deprecated-modules=optparse,tkinter.tix # Create a graph of external dependencies in the given file (report RP0402 must # not be disabled). ext-import-graph= # Create a graph of every (i.e. internal and external) dependencies in the # given file (report RP0402 must not be disabled). import-graph= # Create a graph of internal dependencies in the given file (report RP0402 must # not be disabled). int-import-graph= # Force import order to recognize a module as part of the standard # compatibility libraries. known-standard-library= # Force import order to recognize a module as part of a third party library. known-third-party=enchant [EXCEPTIONS] # Exceptions that will emit a warning when being caught. Defaults to # "BaseException, Exception". overgeneral-exceptions=BaseException, Exception Flask-Seeder-1.2.0/setup.cfg0000664000372000037200000000004613765161112016445 0ustar travistravis00000000000000[egg_info] tag_build = tag_date = 0 Flask-Seeder-1.2.0/Flask_Seeder.egg-info/0000775000372000037200000000000013765161112020645 5ustar travistravis00000000000000Flask-Seeder-1.2.0/Flask_Seeder.egg-info/PKG-INFO0000664000372000037200000001552613765161111021752 0ustar travistravis00000000000000Metadata-Version: 2.1 Name: Flask-Seeder Version: 1.2.0 Summary: Flask extension to seed database through scripts Home-page: https://github.com/diddi-/flask-seeder Author: Diddi Oskarsson Author-email: diddi@diddi.se License: MIT Description: # Flask-Seeder [![Build Status](https://travis-ci.org/diddi-/flask-seeder.svg?branch=master)](https://travis-ci.org/diddi-/flask-seeder) [![Coverage Status](https://coveralls.io/repos/github/diddi-/flask-seeder/badge.svg?branch=master)](https://coveralls.io/github/diddi-/flask-seeder?branch=master) Flask-Seeder is a Flask extension to help with seeding database with initial data, for example when deploying an application for the first time. This extensions primary focus is to help populating data once, for example in a demo application where the database might get wiped over and over but you still want users to have some basic data to play around with. # Installation ``` pip install Flask-Seeder ``` This will install the Flask-Seeder extension and add a `flask seed` subcommand, check it out to see what arguments are supported! # Seeders Flask-Seeder provides a base class `Seeder` that holds a database handle. By subclassing `Seeder` and implementing a `run()` method you get access to the database handle object and can start seeding the database with data. All seeders must be somewhere in the `seeds/` directory and inherit from `Seeder` or else they won't be detected. When all seeders have completed (successfully or not), Flask-Seeder will by default commit all changes to the database. This behaviour can be overridden with `--no-commit` or setting environment variable `FLASK_SEEDER_AUTOCOMMIT=0`. ## Run Order When splitting seeders across multiple classes and files, order of operations is determined by two factors. First the seeders are grouped by `priority` (lower priority will be run first), all seeders with the same priority are then ordered by class name. See example below for setting priority on a seeder. ```python from flask_seeder import Seeder class DemoSeeder(Seeder): def __init__(self, db=None): super().__init__(db=db) self.priority = 10 def run(self): ... ``` # Faker and Generators Flask-Seeder provides a `Faker` class that controls the creation of fake objects, based on real models. By telling `Faker` how to create the objects, you can easily create many different unique objects to help when seeding the database. There are different generators that help generate values for the fake objects. Currently supported generators are: * Integer: Create a random integer between two values * UUID: Create a random UUID * Sequence: Create integers in sequence if called multiple times * Name: Create a random name from a list `data/names/names.txt` * Email: Create a random email, a combination of the random name generator and a domain from `data/domains/domains.txt` * String: String generation from a pattern Feel free to roll your own generator by subclassing `Generator` and implement a `generate()` method that return the generated value. ## String generator pattern The `String` generator takes a pattern and produces a string that matches the pattern. Currently the generator pattern is very simple and supports only a handful of operations. | Pattern | Produces | Description | Example | | --| -- | -- | -- | | [abc] | String character | Randomly select one of the provided characters | `b` | | [a-k] | String character | Randomly select one character from a range | `i` | | \c | String character | Randomly select any alpha character (a-z, A-Z) | `B` | | (one\|two) | String group | Like `[abc]` but works for strings, not just single characters | `one` | | \d | Digit | Randomly select a single digit (0-9) | `8` | | {x} | Repeater | Repeat the previous pattern `x` times | `\d{5}` | | {m,n} | Repeater | Repeat the previous pattern `x` times where `x` is anywhere between `m` and `n` | `[0-9]{2,8}` | | abc | String literal | No processing, returned as is | `abc` | Patterns can also be combined to produce more complex strings. ``` # Produces something like: abc5586oz abc[5-9]{4}\c[xyz] ``` # Example usage Examples show only relevant snippets of code **app.py:** ```python from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_seeder import FlaskSeeder def create_app(): app = Flask(__name__) db = SQLAlchemy() db.init_app(app) seeder = FlaskSeeder() seeder.init_app(app, db) return app ``` **seeds/demo.py:** ```python from flask_seeder import Seeder, Faker, generator # SQLAlchemy database model class User(Base): def __init__(self, id_num=None, name=None, age=None): self.id_num = id_num self.name = name self.age = age def __str__(self): return "ID=%d, Name=%s, Age=%d" % (self.id_num, self.name, self.age) # All seeders inherit from Seeder class DemoSeeder(Seeder): # run() will be called by Flask-Seeder def run(self): # Create a new Faker and tell it how to create User objects faker = Faker( cls=User, init={ "id_num": generator.Sequence(), "name": generator.Name(), "age": generator.Integer(start=20, end=100) } ) # Create 5 users for user in faker.create(5): print("Adding user: %s" % user) self.db.session.add(user) ``` ***Shell*** ```bash $ flask seed run Running database seeders Adding user: ID=1, Name=Fancie, Age=76 Adding user: ID=2, Name=Shela, Age=22 Adding user: ID=3, Name=Jo, Age=33 Adding user: ID=4, Name=Laureen, Age=54 Adding user: ID=5, Name=Tandy, Age=66 DemoSeeder... [OK] Committing to database! ``` Platform: UNKNOWN Classifier: Programming Language :: Python :: 3 Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Description-Content-Type: text/markdown Flask-Seeder-1.2.0/Flask_Seeder.egg-info/dependency_links.txt0000664000372000037200000000000113765161111024712 0ustar travistravis00000000000000 Flask-Seeder-1.2.0/Flask_Seeder.egg-info/top_level.txt0000664000372000037200000000002313765161111023371 0ustar travistravis00000000000000flask_seeder tests Flask-Seeder-1.2.0/Flask_Seeder.egg-info/SOURCES.txt0000664000372000037200000000163313765161111022533 0ustar travistravis00000000000000.coveragerc .pylintrc MANIFEST.in README.md setup.py tox.ini Flask_Seeder.egg-info/PKG-INFO Flask_Seeder.egg-info/SOURCES.txt Flask_Seeder.egg-info/dependency_links.txt Flask_Seeder.egg-info/entry_points.txt Flask_Seeder.egg-info/requires.txt Flask_Seeder.egg-info/top_level.txt flask_seeder/__init__.py flask_seeder/cli.py flask_seeder/faker.py flask_seeder/generator.py flask_seeder/parser.py flask_seeder/seeder.py flask_seeder/data/domains/domains.txt flask_seeder/data/names/names.txt tests/__init__.py tests/test_cli.py tests/test_faker.py tests/test_flask_seeder.py tests/test_seeder.py tests/generator/__init__.py tests/generator/test_email.py tests/generator/test_generator.py tests/generator/test_integer.py tests/generator/test_name.py tests/generator/test_sequence.py tests/generator/test_string.py tests/generator/test_uuid.py tests/parser/__init__.py tests/parser/test_parser.py tests/parser/test_tokenizer.pyFlask-Seeder-1.2.0/Flask_Seeder.egg-info/requires.txt0000664000372000037200000000001513765161111023240 0ustar travistravis00000000000000Flask>=1.0.2 Flask-Seeder-1.2.0/Flask_Seeder.egg-info/entry_points.txt0000664000372000037200000000005713765161111024144 0ustar travistravis00000000000000[flask.commands] seed = flask_seeder.cli:seed Flask-Seeder-1.2.0/flask_seeder/0000775000372000037200000000000013765161112017253 5ustar travistravis00000000000000Flask-Seeder-1.2.0/flask_seeder/seeder.py0000775000372000037200000000061013765161026021100 0ustar travistravis00000000000000""" Base seeder """ # pylint: disable=too-few-public-methods class Seeder: """ Base seeder class """ def __init__(self, db=None): self.db = db self.name = None self.mod_path = None self.file_path = None def run(self): """ Run the seeder script. Must be implemented by the client. """ raise NotImplementedError() Flask-Seeder-1.2.0/flask_seeder/data/0000775000372000037200000000000013765161112020164 5ustar travistravis00000000000000Flask-Seeder-1.2.0/flask_seeder/data/names/0000775000372000037200000000000013765161112021267 5ustar travistravis00000000000000Flask-Seeder-1.2.0/flask_seeder/data/names/names.txt0000664000372000037200000010451313765161026023143 0ustar travistravis00000000000000Aaren Aarika Abagael Abagail Abbe Abbey Abbi Abbie Abby Abbye Abigael Abigail Abigale Abra Ada Adah Adaline Adan Adara Adda Addi Addia Addie Addy Adel Adela Adelaida Adelaide Adele Adelheid Adelice Adelina Adelind Adeline Adella Adelle Adena Adey Adi Adiana Adina Adora Adore Adoree Adorne Adrea Adria Adriaens Adrian Adriana Adriane Adrianna Adrianne Adriena Adrienne Aeriel Aeriela Aeriell Afton Ag Agace Agata Agatha Agathe Aggi Aggie Aggy Agna Agnella Agnes Agnese Agnesse Agneta Agnola Agretha Aida Aidan Aigneis Aila Aile Ailee Aileen Ailene Ailey Aili Ailina Ailis Ailsun Ailyn Aime Aimee Aimil Aindrea Ainslee Ainsley Ainslie Ajay Alaine Alameda Alana Alanah Alane Alanna Alayne Alberta Albertina Albertine Albina Alecia Aleda Aleece Aleen Alejandra Alejandrina Alena Alene Alessandra Aleta Alethea Alex Alexa Alexandra Alexandrina Alexi Alexia Alexina Alexine Alexis Alfi Alfie Alfreda Alfy Ali Alia Alica Alice Alicea Alicia Alida Alidia Alie Alika Alikee Alina Aline Alis Alisa Alisha Alison Alissa Alisun Alix Aliza Alla Alleen Allegra Allene Alli Allianora Allie Allina Allis Allison Allissa Allix Allsun Allx Ally Allyce Allyn Allys Allyson Alma Almeda Almeria Almeta Almira Almire Aloise Aloisia Aloysia Alta Althea Alvera Alverta Alvina Alvinia Alvira Alyce Alyda Alys Alysa Alyse Alysia Alyson Alyss Alyssa Amabel Amabelle Amalea Amalee Amaleta Amalia Amalie Amalita Amalle Amanda Amandi Amandie Amandy Amara Amargo Amata Amber Amberly Ambur Ame Amelia Amelie Amelina Ameline Amelita Ami Amie Amii Amil Amitie Amity Ammamaria Amy Amye Ana Anabal Anabel Anabella Anabelle Analiese Analise Anallese Anallise Anastasia Anastasie Anastassia Anatola Andee Andeee Anderea Andi Andie Andra Andrea Andreana Andree Andrei Andria Andriana Andriette Andromache Andy Anestassia Anet Anett Anetta Anette Ange Angel Angela Angele Angelia Angelica Angelika Angelina Angeline Angelique Angelita Angelle Angie Angil Angy Ania Anica Anissa Anita Anitra Anjanette Anjela Ann Ann-Marie Anna Anna-Diana Anna-Diane Anna-Maria Annabal Annabel Annabela Annabell Annabella Annabelle Annadiana Annadiane Annalee Annaliese Annalise Annamaria Annamarie Anne Anne-Corinne Anne-Marie Annecorinne Anneliese Annelise Annemarie Annetta Annette Anni Annice Annie Annis Annissa Annmaria Annmarie Annnora Annora Anny Anselma Ansley Anstice Anthe Anthea Anthia Anthiathia Antoinette Antonella Antonetta Antonia Antonie Antonietta Antonina Anya Appolonia April Aprilette Ara Arabel Arabela Arabele Arabella Arabelle Arda Ardath Ardeen Ardelia Ardelis Ardella Ardelle Arden Ardene Ardenia Ardine Ardis Ardisj Ardith Ardra Ardyce Ardys Ardyth Aretha Ariadne Ariana Aridatha Ariel Ariela Ariella Arielle Arlana Arlee Arleen Arlen Arlena Arlene Arleta Arlette Arleyne Arlie Arliene Arlina Arlinda Arline Arluene Arly Arlyn Arlyne Aryn Ashely Ashia Ashien Ashil Ashla Ashlan Ashlee Ashleigh Ashlen Ashley Ashli Ashlie Ashly Asia Astra Astrid Astrix Atalanta Athena Athene Atlanta Atlante Auberta Aubine Aubree Aubrette Aubrey Aubrie Aubry Audi Audie Audra Audre Audrey Audrie Audry Audrye Audy Augusta Auguste Augustina Augustine Aundrea Aura Aurea Aurel Aurelea Aurelia Aurelie Auria Aurie Aurilia Aurlie Auroora Aurora Aurore Austin Austina Austine Ava Aveline Averil Averyl Avie Avis Aviva Avivah Avril Avrit Ayn Bab Babara Babb Babbette Babbie Babette Babita Babs Bambi Bambie Bamby Barb Barbabra Barbara Barbara-Anne Barbaraanne Barbe Barbee Barbette Barbey Barbi Barbie Barbra Barby Bari Barrie Barry Basia Bathsheba Batsheva Bea Beatrice Beatrisa Beatrix Beatriz Bebe Becca Becka Becki Beckie Becky Bee Beilul Beitris Bekki Bel Belia Belicia Belinda Belita Bell Bella Bellanca Belle Bellina Belva Belvia Bendite Benedetta Benedicta Benedikta Benetta Benita Benni Bennie Benny Benoite Berenice Beret Berget Berna Bernadene Bernadette Bernadina Bernadine Bernardina Bernardine Bernelle Bernete Bernetta Bernette Berni Bernice Bernie Bernita Berny Berri Berrie Berry Bert Berta Berte Bertha Berthe Berti Bertie Bertina Bertine Berty Beryl Beryle Bess Bessie Bessy Beth Bethanne Bethany Bethena Bethina Betsey Betsy Betta Bette Bette-Ann Betteann Betteanne Betti Bettina Bettine Betty Bettye Beulah Bev Beverie Beverlee Beverley Beverlie Beverly Bevvy Bianca Bianka Bibbie Bibby Bibbye Bibi Biddie Biddy Bidget Bili Bill Billi Billie Billy Billye Binni Binnie Binny Bird Birdie Birgit Birgitta Blair Blaire Blake Blakelee Blakeley Blanca Blanch Blancha Blanche Blinni Blinnie Blinny Bliss Blisse Blithe Blondell Blondelle Blondie Blondy Blythe Bobbe Bobbee Bobbette Bobbi Bobbie Bobby Bobbye Bobette Bobina Bobine Bobinette Bonita Bonnee Bonni Bonnibelle Bonnie Bonny Brana Brandais Brande Brandea Brandi Brandice Brandie Brandise Brandy Breanne Brear Bree Breena Bren Brena Brenda Brenn Brenna Brett Bria Briana Brianna Brianne Bride Bridget Bridgette Bridie Brier Brietta Brigid Brigida Brigit Brigitta Brigitte Brina Briney Brinn Brinna Briny Brit Brita Britney Britni Britt Britta Brittan Brittaney Brittani Brittany Britte Britteny Brittne Brittney Brittni Brook Brooke Brooks Brunhilda Brunhilde Bryana Bryn Bryna Brynn Brynna Brynne Buffy Bunni Bunnie Bunny Cacilia Cacilie Cahra Cairistiona Caitlin Caitrin Cal Calida Calla Calley Calli Callida Callie Cally Calypso Cam Camala Camel Camella Camellia Cami Camila Camile Camilla Camille Cammi Cammie Cammy Candace Candi Candice Candida Candide Candie Candis Candra Candy Caprice Cara Caralie Caren Carena Caresa Caressa Caresse Carey Cari Caria Carie Caril Carilyn Carin Carina Carine Cariotta Carissa Carita Caritta Carla Carlee Carleen Carlen Carlene Carley Carlie Carlin Carlina Carline Carlita Carlota Carlotta Carly Carlye Carlyn Carlynn Carlynne Carma Carmel Carmela Carmelia Carmelina Carmelita Carmella Carmelle Carmen Carmencita Carmina Carmine Carmita Carmon Caro Carol Carol-Jean Carola Carolan Carolann Carole Carolee Carolin Carolina Caroline Caroljean Carolyn Carolyne Carolynn Caron Carree Carri Carrie Carrissa Carroll Carry Cary Caryl Caryn Casandra Casey Casi Casie Cass Cassandra Cassandre Cassandry Cassaundra Cassey Cassi Cassie Cassondra Cassy Catarina Cate Caterina Catha Catharina Catharine Cathe Cathee Catherin Catherina Catherine Cathi Cathie Cathleen Cathlene Cathrin Cathrine Cathryn Cathy Cathyleen Cati Catie Catina Catlaina Catlee Catlin Catrina Catriona Caty Caye Cayla Cecelia Cecil Cecile Ceciley Cecilia Cecilla Cecily Ceil Cele Celene Celesta Celeste Celestia Celestina Celestine Celestyn Celestyna Celia Celie Celina Celinda Celine Celinka Celisse Celka Celle Cesya Chad Chanda Chandal Chandra Channa Chantal Chantalle Charil Charin Charis Charissa Charisse Charita Charity Charla Charlean Charleen Charlena Charlene Charline Charlot Charlotta Charlotte Charmain Charmaine Charmane Charmian Charmine Charmion Charo Charyl Chastity Chelsae Chelsea Chelsey Chelsie Chelsy Cher Chere Cherey Cheri Cherianne Cherice Cherida Cherie Cherilyn Cherilynn Cherin Cherise Cherish Cherlyn Cherri Cherrita Cherry Chery Cherye Cheryl Cheslie Chiarra Chickie Chicky Chiquia Chiquita Chlo Chloe Chloette Chloris Chris Chrissie Chrissy Christa Christabel Christabella Christal Christalle Christan Christean Christel Christen Christi Christian Christiana Christiane Christie Christin Christina Christine Christy Christye Christyna Chrysa Chrysler Chrystal Chryste Chrystel Cicely Cicily Ciel Cilka Cinda Cindee Cindelyn Cinderella Cindi Cindie Cindra Cindy Cinnamon Cissiee Cissy Clair Claire Clara Clarabelle Clare Claresta Clareta Claretta Clarette Clarey Clari Claribel Clarice Clarie Clarinda Clarine Clarissa Clarisse Clarita Clary Claude Claudelle Claudetta Claudette Claudia Claudie Claudina Claudine Clea Clem Clemence Clementia Clementina Clementine Clemmie Clemmy Cleo Cleopatra Clerissa Clio Clo Cloe Cloris Clotilda Clovis Codee Codi Codie Cody Coleen Colene Coletta Colette Colleen Collen Collete Collette Collie Colline Colly Con Concettina Conchita Concordia Conni Connie Conny Consolata Constance Constancia Constancy Constanta Constantia Constantina Constantine Consuela Consuelo Cookie Cora Corabel Corabella Corabelle Coral Coralie Coraline Coralyn Cordelia Cordelie Cordey Cordi Cordie Cordula Cordy Coreen Corella Corenda Corene Coretta Corette Corey Cori Corie Corilla Corina Corine Corinna Corinne Coriss Corissa Corliss Corly Cornela Cornelia Cornelle Cornie Corny Correna Correy Corri Corrianne Corrie Corrina Corrine Corrinne Corry Cortney Cory Cosetta Cosette Costanza Courtenay Courtnay Courtney Crin Cris Crissie Crissy Crista Cristabel Cristal Cristen Cristi Cristie Cristin Cristina Cristine Cristionna Cristy Crysta Crystal Crystie Cthrine Cyb Cybil Cybill Cymbre Cynde Cyndi Cyndia Cyndie Cyndy Cynthea Cynthia Cynthie Cynthy Dacey Dacia Dacie Dacy Dael Daffi Daffie Daffy Dagmar Dahlia Daile Daisey Daisi Daisie Daisy Dale Dalenna Dalia Dalila Dallas Daloris Damara Damaris Damita Dana Danell Danella Danette Dani Dania Danica Danice Daniela Daniele Daniella Danielle Danika Danila Danit Danita Danna Danni Dannie Danny Dannye Danya Danyelle Danyette Daphene Daphna Daphne Dara Darb Darbie Darby Darcee Darcey Darci Darcie Darcy Darda Dareen Darell Darelle Dari Daria Darice Darla Darleen Darlene Darline Darlleen Daron Darrelle Darryl Darsey Darsie Darya Daryl Daryn Dasha Dasi Dasie Dasya Datha Daune Daveen Daveta Davida Davina Davine Davita Dawn Dawna Dayle Dayna Ddene De Deana Deane Deanna Deanne Deb Debbi Debbie Debby Debee Debera Debi Debor Debora Deborah Debra Dede Dedie Dedra Dee Dee Dee Deeann Deeanne Deedee Deena Deerdre Deeyn Dehlia Deidre Deina Deirdre Del Dela Delcina Delcine Delia Delila Delilah Delinda Dell Della Delly Delora Delores Deloria Deloris Delphine Delphinia Demeter Demetra Demetria Demetris Dena Deni Denice Denise Denna Denni Dennie Denny Deny Denys Denyse Deonne Desdemona Desirae Desiree Desiri Deva Devan Devi Devin Devina Devinne Devon Devondra Devonna Devonne Devora Di Diahann Dian Diana Diandra Diane Diane-Marie Dianemarie Diann Dianna Dianne Diannne Didi Dido Diena Dierdre Dina Dinah Dinnie Dinny Dion Dione Dionis Dionne Dita Dix Dixie Dniren Dode Dodi Dodie Dody Doe Doll Dolley Dolli Dollie Dolly Dolores Dolorita Doloritas Domeniga Dominga Domini Dominica Dominique Dona Donella Donelle Donetta Donia Donica Donielle Donna Donnamarie Donni Donnie Donny Dora Doralia Doralin Doralyn Doralynn Doralynne Dore Doreen Dorelia Dorella Dorelle Dorena Dorene Doretta Dorette Dorey Dori Doria Dorian Dorice Dorie Dorine Doris Dorisa Dorise Dorita Doro Dorolice Dorolisa Dorotea Doroteya Dorothea Dorothee Dorothy Dorree Dorri Dorrie Dorris Dorry Dorthea Dorthy Dory Dosi Dot Doti Dotti Dottie Dotty Dre Dreddy Dredi Drona Dru Druci Drucie Drucill Drucy Drusi Drusie Drusilla Drusy Dulce Dulcea Dulci Dulcia Dulciana Dulcie Dulcine Dulcinea Dulcy Dulsea Dusty Dyan Dyana Dyane Dyann Dyanna Dyanne Dyna Dynah Eachelle Eada Eadie Eadith Ealasaid Eartha Easter Eba Ebba Ebonee Ebony Eda Eddi Eddie Eddy Ede Edee Edeline Eden Edi Edie Edin Edita Edith Editha Edithe Ediva Edna Edwina Edy Edyth Edythe Effie Eileen Eilis Eimile Eirena Ekaterina Elaina Elaine Elana Elane Elayne Elberta Elbertina Elbertine Eleanor Eleanora Eleanore Electra Eleen Elena Elene Eleni Elenore Eleonora Eleonore Elfie Elfreda Elfrida Elfrieda Elga Elianora Elianore Elicia Elie Elinor Elinore Elisa Elisabet Elisabeth Elisabetta Elise Elisha Elissa Elita Eliza Elizabet Elizabeth Elka Elke Ella Elladine Elle Ellen Ellene Ellette Elli Ellie Ellissa Elly Ellyn Ellynn Elmira Elna Elnora Elnore Eloisa Eloise Elonore Elora Elsa Elsbeth Else Elset Elsey Elsi Elsie Elsinore Elspeth Elsy Elva Elvera Elvina Elvira Elwira Elyn Elyse Elysee Elysha Elysia Elyssa Em Ema Emalee Emalia Emelda Emelia Emelina Emeline Emelita Emelyne Emera Emilee Emili Emilia Emilie Emiline Emily Emlyn Emlynn Emlynne Emma Emmalee Emmaline Emmalyn Emmalynn Emmalynne Emmeline Emmey Emmi Emmie Emmy Emmye Emogene Emyle Emylee Engracia Enid Enrica Enrichetta Enrika Enriqueta Eolanda Eolande Eran Erda Erena Erica Ericha Ericka Erika Erin Erina Erinn Erinna Erma Ermengarde Ermentrude Ermina Erminia Erminie Erna Ernaline Ernesta Ernestine Ertha Eryn Esma Esmaria Esme Esmeralda Essa Essie Essy Esta Estel Estele Estell Estella Estelle Ester Esther Estrella Estrellita Ethel Ethelda Ethelin Ethelind Etheline Ethelyn Ethyl Etta Etti Ettie Etty Eudora Eugenia Eugenie Eugine Eula Eulalie Eunice Euphemia Eustacia Eva Evaleen Evangelia Evangelin Evangelina Evangeline Evania Evanne Eve Eveleen Evelina Eveline Evelyn Evey Evie Evita Evonne Evvie Evvy Evy Eyde Eydie Ezmeralda Fae Faina Faith Fallon Fan Fanchette Fanchon Fancie Fancy Fanechka Fania Fanni Fannie Fanny Fanya Fara Farah Farand Farica Farra Farrah Farrand Faun Faunie Faustina Faustine Fawn Fawne Fawnia Fay Faydra Faye Fayette Fayina Fayre Fayth Faythe Federica Fedora Felecia Felicdad Felice Felicia Felicity Felicle Felipa Felisha Felita Feliza Fenelia Feodora Ferdinanda Ferdinande Fern Fernanda Fernande Fernandina Ferne Fey Fiann Fianna Fidela Fidelia Fidelity Fifi Fifine Filia Filide Filippa Fina Fiona Fionna Fionnula Fiorenze Fleur Fleurette Flo Flor Flora Florance Flore Florella Florence Florencia Florentia Florenza Florette Flori Floria Florida Florie Florina Florinda Floris Florri Florrie Florry Flory Flossi Flossie Flossy Flss Fran Francene Frances Francesca Francine Francisca Franciska Francoise Francyne Frank Frankie Franky Franni Frannie Franny Frayda Fred Freda Freddi Freddie Freddy Fredelia Frederica Fredericka Frederique Fredi Fredia Fredra Fredrika Freida Frieda Friederike Fulvia Gabbey Gabbi Gabbie Gabey Gabi Gabie Gabriel Gabriela Gabriell Gabriella Gabrielle Gabriellia Gabrila Gaby Gae Gael Gail Gale Galina Garland Garnet Garnette Gates Gavra Gavrielle Gay Gaye Gayel Gayla Gayle Gayleen Gaylene Gaynor Gelya Gena Gene Geneva Genevieve Genevra Genia Genna Genni Gennie Gennifer Genny Genovera Genvieve George Georgeanna Georgeanne Georgena Georgeta Georgetta Georgette Georgia Georgiana Georgianna Georgianne Georgie Georgina Georgine Geralda Geraldine Gerda Gerhardine Geri Gerianna Gerianne Gerladina Germain Germaine Germana Gerri Gerrie Gerrilee Gerry Gert Gerta Gerti Gertie Gertrud Gertruda Gertrude Gertrudis Gerty Giacinta Giana Gianina Gianna Gigi Gilberta Gilberte Gilbertina Gilbertine Gilda Gilemette Gill Gillan Gilli Gillian Gillie Gilligan Gilly Gina Ginelle Ginevra Ginger Ginni Ginnie Ginnifer Ginny Giorgia Giovanna Gipsy Giralda Gisela Gisele Gisella Giselle Giuditta Giulia Giulietta Giustina Gizela Glad Gladi Gladys Gleda Glen Glenda Glenine Glenn Glenna Glennie Glennis Glori Gloria Gloriana Gloriane Glory Glyn Glynda Glynis Glynnis Gnni Godiva Golda Goldarina Goldi Goldia Goldie Goldina Goldy Grace Gracia Gracie Grata Gratia Gratiana Gray Grayce Grazia Greer Greta Gretal Gretchen Grete Gretel Grethel Gretna Gretta Grier Griselda Grissel Guendolen Guenevere Guenna Guglielma Gui Guillema Guillemette Guinevere Guinna Gunilla Gus Gusella Gussi Gussie Gussy Gusta Gusti Gustie Gusty Gwen Gwendolen Gwendolin Gwendolyn Gweneth Gwenette Gwenneth Gwenni Gwennie Gwenny Gwenora Gwenore Gwyn Gwyneth Gwynne Gypsy Hadria Hailee Haily Haleigh Halette Haley Hali Halie Halimeda Halley Halli Hallie Hally Hana Hanna Hannah Hanni Hannie Hannis Hanny Happy Harlene Harley Harli Harlie Harmonia Harmonie Harmony Harri Harrie Harriet Harriett Harrietta Harriette Harriot Harriott Hatti Hattie Hatty Hayley Hazel Heath Heather Heda Hedda Heddi Heddie Hedi Hedvig Hedvige Hedwig Hedwiga Hedy Heida Heidi Heidie Helaina Helaine Helen Helen-Elizabeth Helena Helene Helenka Helga Helge Helli Heloise Helsa Helyn Hendrika Henka Henrie Henrieta Henrietta Henriette Henryetta Hephzibah Hermia Hermina Hermine Herminia Hermione Herta Hertha Hester Hesther Hestia Hetti Hettie Hetty Hilary Hilda Hildagard Hildagarde Hilde Hildegaard Hildegarde Hildy Hillary Hilliary Hinda Holli Hollie Holly Holly-Anne Hollyanne Honey Honor Honoria Hope Horatia Hortense Hortensia Hulda Hyacinth Hyacintha Hyacinthe Hyacinthia Hyacinthie Hynda Ianthe Ibbie Ibby Ida Idalia Idalina Idaline Idell Idelle Idette Ileana Ileane Ilene Ilise Ilka Illa Ilsa Ilse Ilysa Ilyse Ilyssa Imelda Imogen Imogene Imojean Ina Indira Ines Inesita Inessa Inez Inga Ingaberg Ingaborg Inge Ingeberg Ingeborg Inger Ingrid Ingunna Inna Iolande Iolanthe Iona Iormina Ira Irena Irene Irina Iris Irita Irma Isa Isabel Isabelita Isabella Isabelle Isadora Isahella Iseabal Isidora Isis Isobel Issi Issie Issy Ivett Ivette Ivie Ivonne Ivory Ivy Izabel Jacenta Jacinda Jacinta Jacintha Jacinthe Jackelyn Jacki Jackie Jacklin Jacklyn Jackquelin Jackqueline Jacky Jaclin Jaclyn Jacquelin Jacqueline Jacquelyn Jacquelynn Jacquenetta Jacquenette Jacquetta Jacquette Jacqui Jacquie Jacynth Jada Jade Jaime Jaimie Jaine Jami Jamie Jamima Jammie Jan Jana Janaya Janaye Jandy Jane Janean Janeczka Janeen Janel Janela Janella Janelle Janene Janenna Janessa Janet Janeta Janetta Janette Janeva Janey Jania Janice Janie Janifer Janina Janine Janis Janith Janka Janna Jannel Jannelle Janot Jany Jaquelin Jaquelyn Jaquenetta Jaquenette Jaquith Jasmin Jasmina Jasmine Jayme Jaymee Jayne Jaynell Jazmin Jean Jeana Jeane Jeanelle Jeanette Jeanie Jeanine Jeanna Jeanne Jeannette Jeannie Jeannine Jehanna Jelene Jemie Jemima Jemimah Jemmie Jemmy Jen Jena Jenda Jenelle Jeni Jenica Jeniece Jenifer Jeniffer Jenilee Jenine Jenn Jenna Jennee Jennette Jenni Jennica Jennie Jennifer Jennilee Jennine Jenny Jeralee Jere Jeri Jermaine Jerrie Jerrilee Jerrilyn Jerrine Jerry Jerrylee Jess Jessa Jessalin Jessalyn Jessamine Jessamyn Jesse Jesselyn Jessi Jessica Jessie Jessika Jessy Jewel Jewell Jewelle Jill Jillana Jillane Jillayne Jilleen Jillene Jilli Jillian Jillie Jilly Jinny Jo Jo Ann Jo-Ann Jo-Anne Joan Joana Joane Joanie Joann Joanna Joanne Joannes Jobey Jobi Jobie Jobina Joby Jobye Jobyna Jocelin Joceline Jocelyn Jocelyne Jodee Jodi Jodie Jody Joeann Joela Joelie Joell Joella Joelle Joellen Joelly Joellyn Joelynn Joete Joey Johanna Johannah Johna Johnath Johnette Johnna Joice Jojo Jolee Joleen Jolene Joletta Joli Jolie Joline Joly Jolyn Jolynn Jonell Joni Jonie Jonis Jordain Jordan Jordana Jordanna Jorey Jori Jorie Jorrie Jorry Joscelin Josee Josefa Josefina Josepha Josephina Josephine Josey Josi Josie Josselyn Josy Jourdan Joy Joya Joyan Joyann Joyce Joycelin Joye Jsandye Juana Juanita Judi Judie Judith Juditha Judy Judye Juieta Julee Juli Julia Juliana Juliane Juliann Julianna Julianne Julie Julienne Juliet Julieta Julietta Juliette Julina Juline Julissa Julita June Junette Junia Junie Junina Justina Justine Justinn Jyoti Kacey Kacie Kacy Kaela Kai Kaia Kaila Kaile Kailey Kaitlin Kaitlyn Kaitlynn Kaja Kakalina Kala Kaleena Kali Kalie Kalila Kalina Kalinda Kalindi Kalli Kally Kameko Kamila Kamilah Kamillah Kandace Kandy Kania Kanya Kara Kara-Lynn Karalee Karalynn Kare Karee Karel Karen Karena Kari Karia Karie Karil Karilynn Karin Karina Karine Kariotta Karisa Karissa Karita Karla Karlee Karleen Karlen Karlene Karlie Karlotta Karlotte Karly Karlyn Karmen Karna Karol Karola Karole Karolina Karoline Karoly Karon Karrah Karrie Karry Kary Karyl Karylin Karyn Kasey Kass Kassandra Kassey Kassi Kassia Kassie Kat Kata Katalin Kate Katee Katerina Katerine Katey Kath Katha Katharina Katharine Katharyn Kathe Katherina Katherine Katheryn Kathi Kathie Kathleen Kathlin Kathrine Kathryn Kathryne Kathy Kathye Kati Katie Katina Katine Katinka Katleen Katlin Katrina Katrine Katrinka Katti Kattie Katuscha Katusha Katy Katya Kay Kaycee Kaye Kayla Kayle Kaylee Kayley Kaylil Kaylyn Keeley Keelia Keely Kelcey Kelci Kelcie Kelcy Kelila Kellen Kelley Kelli Kellia Kellie Kellina Kellsie Kelly Kellyann Kelsey Kelsi Kelsy Kendra Kendre Kenna Keri Keriann Kerianne Kerri Kerrie Kerrill Kerrin Kerry Kerstin Kesley Keslie Kessia Kessiah Ketti Kettie Ketty Kevina Kevyn Ki Kiah Kial Kiele Kiersten Kikelia Kiley Kim Kimberlee Kimberley Kimberli Kimberly Kimberlyn Kimbra Kimmi Kimmie Kimmy Kinna Kip Kipp Kippie Kippy Kira Kirbee Kirbie Kirby Kiri Kirsten Kirsteni Kirsti Kirstin Kirstyn Kissee Kissiah Kissie Kit Kitti Kittie Kitty Kizzee Kizzie Klara Klarika Klarrisa Konstance Konstanze Koo Kora Koral Koralle Kordula Kore Korella Koren Koressa Kori Korie Korney Korrie Korry Kris Krissie Krissy Krista Kristal Kristan Kriste Kristel Kristen Kristi Kristien Kristin Kristina Kristine Kristy Kristyn Krysta Krystal Krystalle Krystle Krystyna Kyla Kyle Kylen Kylie Kylila Kylynn Kym Kynthia Kyrstin La Verne Lacee Lacey Lacie Lacy Ladonna Laetitia Laina Lainey Lana Lanae Lane Lanette Laney Lani Lanie Lanita Lanna Lanni Lanny Lara Laraine Lari Larina Larine Larisa Larissa Lark Laryssa Latashia Latia Latisha Latrena Latrina Laura Lauraine Laural Lauralee Laure Lauree Laureen Laurel Laurella Lauren Laurena Laurene Lauretta Laurette Lauri Laurianne Laurice Laurie Lauryn Lavena Laverna Laverne Lavina Lavinia Lavinie Layla Layne Layney Lea Leah Leandra Leann Leanna Leanor Leanora Lebbie Leda Lee Leeann Leeanne Leela Leelah Leena Leesa Leese Legra Leia Leigh Leigha Leila Leilah Leisha Lela Lelah Leland Lelia Lena Lenee Lenette Lenka Lenna Lenora Lenore Leodora Leoine Leola Leoline Leona Leonanie Leone Leonelle Leonie Leonora Leonore Leontine Leontyne Leora Leshia Lesley Lesli Leslie Lesly Lesya Leta Lethia Leticia Letisha Letitia Letizia Letta Letti Lettie Letty Lexi Lexie Lexine Lexis Lexy Leyla Lezlie Lia Lian Liana Liane Lianna Lianne Lib Libbey Libbi Libbie Libby Licha Lida Lidia Liesa Lil Lila Lilah Lilas Lilia Lilian Liliane Lilias Lilith Lilla Lilli Lillian Lillis Lilllie Lilly Lily Lilyan Lin Lina Lind Linda Lindi Lindie Lindsay Lindsey Lindsy Lindy Linea Linell Linet Linette Linn Linnea Linnell Linnet Linnie Linzy Lira Lisa Lisabeth Lisbeth Lise Lisetta Lisette Lisha Lishe Lissa Lissi Lissie Lissy Lita Liuka Liv Liva Livia Livvie Livvy Livvyy Livy Liz Liza Lizabeth Lizbeth Lizette Lizzie Lizzy Loella Lois Loise Lola Loleta Lolita Lolly Lona Lonee Loni Lonna Lonni Lonnie Lora Lorain Loraine Loralee Loralie Loralyn Loree Loreen Lorelei Lorelle Loren Lorena Lorene Lorenza Loretta Lorette Lori Loria Lorianna Lorianne Lorie Lorilee Lorilyn Lorinda Lorine Lorita Lorna Lorne Lorraine Lorrayne Lorri Lorrie Lorrin Lorry Lory Lotta Lotte Lotti Lottie Lotty Lou Louella Louisa Louise Louisette Loutitia Lu Luce Luci Lucia Luciana Lucie Lucienne Lucila Lucilia Lucille Lucina Lucinda Lucine Lucita Lucky Lucretia Lucy Ludovika Luella Luelle Luisa Luise Lula Lulita Lulu Lura Lurette Lurleen Lurlene Lurline Lusa Luz Lyda Lydia Lydie Lyn Lynda Lynde Lyndel Lyndell Lyndsay Lyndsey Lyndsie Lyndy Lynea Lynelle Lynett Lynette Lynn Lynna Lynne Lynnea Lynnell Lynnelle Lynnet Lynnett Lynnette Lynsey Lyssa Mab Mabel Mabelle Mable Mada Madalena Madalyn Maddalena Maddi Maddie Maddy Madel Madelaine Madeleine Madelena Madelene Madelin Madelina Madeline Madella Madelle Madelon Madelyn Madge Madlen Madlin Madonna Mady Mae Maegan Mag Magda Magdaia Magdalen Magdalena Magdalene Maggee Maggi Maggie Maggy Mahala Mahalia Maia Maible Maiga Maighdiln Mair Maire Maisey Maisie Maitilde Mala Malanie Malena Malia Malina Malinda Malinde Malissa Malissia Mallissa Mallorie Mallory Malorie Malory Malva Malvina Malynda Mame Mamie Manda Mandi Mandie Mandy Manon Manya Mara Marabel Marcela Marcelia Marcella Marcelle Marcellina Marcelline Marchelle Marci Marcia Marcie Marcile Marcille Marcy Mareah Maren Marena Maressa Marga Margalit Margalo Margaret Margareta Margarete Margaretha Margarethe Margaretta Margarette Margarita Margaux Marge Margeaux Margery Marget Margette Margi Margie Margit Margo Margot Margret Marguerite Margy Mari Maria Mariam Marian Mariana Mariann Marianna Marianne Maribel Maribelle Maribeth Marice Maridel Marie Marie-Ann Marie-Jeanne Marieann Mariejeanne Mariel Mariele Marielle Mariellen Marietta Mariette Marigold Marijo Marika Marilee Marilin Marillin Marilyn Marin Marina Marinna Marion Mariquilla Maris Marisa Mariska Marissa Marita Maritsa Mariya Marj Marja Marje Marji Marjie Marjorie Marjory Marjy Marketa Marla Marlane Marleah Marlee Marleen Marlena Marlene Marley Marlie Marline Marlo Marlyn Marna Marne Marney Marni Marnia Marnie Marquita Marrilee Marris Marrissa Marsha Marsiella Marta Martelle Martguerita Martha Marthe Marthena Marti Martica Martie Martina Martita Marty Martynne Mary Marya Maryann Maryanna Maryanne Marybelle Marybeth Maryellen Maryjane Maryjo Maryl Marylee Marylin Marylinda Marylou Marylynne Maryrose Marys Marysa Masha Matelda Mathilda Mathilde Matilda Matilde Matti Mattie Matty Maud Maude Maudie Maura Maure Maureen Maureene Maurene Maurine Maurise Maurita Maurizia Mavis Mavra Max Maxi Maxie Maxine Maxy May Maybelle Maye Mead Meade Meagan Meaghan Meara Mechelle Meg Megan Megen Meggi Meggie Meggy Meghan Meghann Mehetabel Mei Mel Mela Melamie Melania Melanie Melantha Melany Melba Melesa Melessa Melicent Melina Melinda Melinde Melisa Melisande Melisandra Melisenda Melisent Melissa Melisse Melita Melitta Mella Melli Mellicent Mellie Mellisa Mellisent Melloney Melly Melodee Melodie Melody Melonie Melony Melosa Melva Mercedes Merci Mercie Mercy Meredith Meredithe Meridel Meridith Meriel Merilee Merilyn Meris Merissa Merl Merla Merle Merlina Merline Merna Merola Merralee Merridie Merrie Merrielle Merrile Merrilee Merrili Merrill Merrily Merry Mersey Meryl Meta Mia Micaela Michaela Michaelina Michaeline Michaella Michal Michel Michele Michelina Micheline Michell Michelle Micki Mickie Micky Midge Mignon Mignonne Miguela Miguelita Mikaela Mil Mildred Mildrid Milena Milicent Milissent Milka Milli Millicent Millie Millisent Milly Milzie Mimi Min Mina Minda Mindy Minerva Minetta Minette Minna Minnaminnie Minne Minni Minnie Minnnie Minny Minta Miof Mela Miquela Mira Mirabel Mirabella Mirabelle Miran Miranda Mireielle Mireille Mirella Mirelle Miriam Mirilla Mirna Misha Missie Missy Misti Misty Mitzi Modesta Modestia Modestine Modesty Moina Moira Moll Mollee Molli Mollie Molly Mommy Mona Monah Monica Monika Monique Mora Moreen Morena Morgan Morgana Morganica Morganne Morgen Moria Morissa Morna Moselle Moyna Moyra Mozelle Muffin Mufi Mufinella Muire Mureil Murial Muriel Murielle Myra Myrah Myranda Myriam Myrilla Myrle Myrlene Myrna Myrta Myrtia Myrtice Myrtie Myrtle Nada Nadean Nadeen Nadia Nadine Nadiya Nady Nadya Nalani Nan Nana Nananne Nance Nancee Nancey Nanci Nancie Nancy Nanete Nanette Nani Nanice Nanine Nannette Nanni Nannie Nanny Nanon Naoma Naomi Nara Nari Nariko Nat Nata Natala Natalee Natalie Natalina Nataline Natalya Natasha Natassia Nathalia Nathalie Natividad Natka Natty Neala Neda Nedda Nedi Neely Neila Neile Neilla Neille Nelia Nelie Nell Nelle Nelli Nellie Nelly Nerissa Nerita Nert Nerta Nerte Nerti Nertie Nerty Nessa Nessi Nessie Nessy Nesta Netta Netti Nettie Nettle Netty Nevsa Neysa Nichol Nichole Nicholle Nicki Nickie Nicky Nicol Nicola Nicole Nicolea Nicolette Nicoli Nicolina Nicoline Nicolle Nikaniki Nike Niki Nikki Nikkie Nikoletta Nikolia Nina Ninetta Ninette Ninnetta Ninnette Ninon Nissa Nisse Nissie Nissy Nita Nixie Noami Noel Noelani Noell Noella Noelle Noellyn Noelyn Noemi Nola Nolana Nolie Nollie Nomi Nona Nonah Noni Nonie Nonna Nonnah Nora Norah Norean Noreen Norene Norina Norine Norma Norri Norrie Norry Novelia Nydia Nyssa Octavia Odele Odelia Odelinda Odella Odelle Odessa Odetta Odette Odilia Odille Ofelia Ofella Ofilia Ola Olenka Olga Olia Olimpia Olive Olivette Olivia Olivie Oliy Ollie Olly Olva Olwen Olympe Olympia Olympie Ondrea Oneida Onida Oona Opal Opalina Opaline Ophelia Ophelie Ora Oralee Oralia Oralie Oralla Oralle Orel Orelee Orelia Orelie Orella Orelle Oriana Orly Orsa Orsola Ortensia Otha Othelia Othella Othilia Othilie Ottilie Page Paige Paloma Pam Pamela Pamelina Pamella Pammi Pammie Pammy Pandora Pansie Pansy Paola Paolina Papagena Pat Patience Patrica Patrice Patricia Patrizia Patsy Patti Pattie Patty Paula Paule Pauletta Paulette Pauli Paulie Paulina Pauline Paulita Pauly Pavia Pavla Pearl Pearla Pearle Pearline Peg Pegeen Peggi Peggie Peggy Pen Penelopa Penelope Penni Pennie Penny Pepi Pepita Peri Peria Perl Perla Perle Perri Perrine Perry Persis Pet Peta Petra Petrina Petronella Petronia Petronilla Petronille Petunia Phaedra Phaidra Phebe Phedra Phelia Phil Philipa Philippa Philippe Philippine Philis Phillida Phillie Phillis Philly Philomena Phoebe Phylis Phyllida Phyllis Phyllys Phylys Pia Pier Pierette Pierrette Pietra Piper Pippa Pippy Polly Pollyanna Pooh Poppy Portia Pris Prisca Priscella Priscilla Prissie Pru Prudence Prudi Prudy Prue Queenie Quentin Querida Quinn Quinta Quintana Quintilla Quintina Rachael Rachel Rachele Rachelle Rae Raeann Raf Rafa Rafaela Rafaelia Rafaelita Rahal Rahel Raina Raine Rakel Ralina Ramona Ramonda Rana Randa Randee Randene Randi Randie Randy Ranee Rani Rania Ranice Ranique Ranna Raphaela Raquel Raquela Rasia Rasla Raven Ray Raychel Raye Rayna Raynell Rayshell Rea Reba Rebbecca Rebe Rebeca Rebecca Rebecka Rebeka Rebekah Rebekkah Ree Reeba Reena Reeta Reeva Regan Reggi Reggie Regina Regine Reiko Reina Reine Remy Rena Renae Renata Renate Rene Renee Renell Renelle Renie Rennie Reta Retha Revkah Rey Reyna Rhea Rheba Rheta Rhetta Rhiamon Rhianna Rhianon Rhoda Rhodia Rhodie Rhody Rhona Rhonda Riane Riannon Rianon Rica Ricca Rici Ricki Rickie Ricky Riki Rikki Rina Risa Rita Riva Rivalee Rivi Rivkah Rivy Roana Roanna Roanne Robbi Robbie Robbin Robby Robbyn Robena Robenia Roberta Robin Robina Robinet Robinett Robinetta Robinette Robinia Roby Robyn Roch Rochell Rochella Rochelle Rochette Roda Rodi Rodie Rodina Rois Romola Romona Romonda Romy Rona Ronalda Ronda Ronica Ronna Ronni Ronnica Ronnie Ronny Roobbie Rora Rori Rorie Rory Ros Rosa Rosabel Rosabella Rosabelle Rosaleen Rosalia Rosalie Rosalind Rosalinda Rosalinde Rosaline Rosalyn Rosalynd Rosamond Rosamund Rosana Rosanna Rosanne Rose Roseann Roseanna Roseanne Roselia Roselin Roseline Rosella Roselle Rosemaria Rosemarie Rosemary Rosemonde Rosene Rosetta Rosette Roshelle Rosie Rosina Rosita Roslyn Rosmunda Rosy Row Rowe Rowena Roxana Roxane Roxanna Roxanne Roxi Roxie Roxine Roxy Roz Rozalie Rozalin Rozamond Rozanna Rozanne Roze Rozele Rozella Rozelle Rozina Rubetta Rubi Rubia Rubie Rubina Ruby Ruperta Ruth Ruthann Ruthanne Ruthe Ruthi Ruthie Ruthy Ryann Rycca Saba Sabina Sabine Sabra Sabrina Sacha Sada Sadella Sadie Sadye Saidee Sal Salaidh Sallee Salli Sallie Sally Sallyann Sallyanne Saloma Salome Salomi Sam Samantha Samara Samaria Sammy Sande Sandi Sandie Sandra Sandy Sandye Sapphira Sapphire Sara Sara-Ann Saraann Sarah Sarajane Saree Sarena Sarene Sarette Sari Sarina Sarine Sarita Sascha Sasha Sashenka Saudra Saundra Savina Sayre Scarlet Scarlett Sean Seana Seka Sela Selena Selene Selestina Selia Selie Selina Selinda Seline Sella Selle Selma Sena Sephira Serena Serene Shae Shaina Shaine Shalna Shalne Shana Shanda Shandee Shandeigh Shandie Shandra Shandy Shane Shani Shanie Shanna Shannah Shannen Shannon Shanon Shanta Shantee Shara Sharai Shari Sharia Sharity Sharl Sharla Sharleen Sharlene Sharline Sharon Sharona Sharron Sharyl Shaun Shauna Shawn Shawna Shawnee Shay Shayla Shaylah Shaylyn Shaylynn Shayna Shayne Shea Sheba Sheela Sheelagh Sheelah Sheena Sheeree Sheila Sheila-Kathryn Sheilah Shel Shela Shelagh Shelba Shelbi Shelby Shelia Shell Shelley Shelli Shellie Shelly Shena Sher Sheree Sheri Sherie Sherill Sherilyn Sherline Sherri Sherrie Sherry Sherye Sheryl Shina Shir Shirl Shirlee Shirleen Shirlene Shirley Shirline Shoshana Shoshanna Siana Sianna Sib Sibbie Sibby Sibeal Sibel Sibella Sibelle Sibilla Sibley Sibyl Sibylla Sibylle Sidoney Sidonia Sidonnie Sigrid Sile Sileas Silva Silvana Silvia Silvie Simona Simone Simonette Simonne Sindee Siobhan Sioux Siouxie Sisely Sisile Sissie Sissy Siusan Sofia Sofie Sondra Sonia Sonja Sonni Sonnie Sonnnie Sonny Sonya Sophey Sophi Sophia Sophie Sophronia Sorcha Sosanna Stace Stacee Stacey Staci Stacia Stacie Stacy Stafani Star Starla Starlene Starlin Starr Stefa Stefania Stefanie Steffane Steffi Steffie Stella Stepha Stephana Stephani Stephanie Stephannie Stephenie Stephi Stephie Stephine Stesha Stevana Stevena Stoddard Storm Stormi Stormie Stormy Sue Suellen Sukey Suki Sula Sunny Sunshine Susan Susana Susanetta Susann Susanna Susannah Susanne Susette Susi Susie Susy Suzann Suzanna Suzanne Suzette Suzi Suzie Suzy Sybil Sybila Sybilla Sybille Sybyl Sydel Sydelle Sydney Sylvia Tabatha Tabbatha Tabbi Tabbie Tabbitha Tabby Tabina Tabitha Taffy Talia Tallia Tallie Tallou Tallulah Tally Talya Talyah Tamar Tamara Tamarah Tamarra Tamera Tami Tamiko Tamma Tammara Tammi Tammie Tammy Tamqrah Tamra Tana Tandi Tandie Tandy Tanhya Tani Tania Tanitansy Tansy Tanya Tara Tarah Tarra Tarrah Taryn Tasha Tasia Tate Tatiana Tatiania Tatum Tawnya Tawsha Ted Tedda Teddi Teddie Teddy Tedi Tedra Teena TEirtza Teodora Tera Teresa Terese Teresina Teresita Teressa Teri Teriann Terra Terri Terrie Terrijo Terry Terrye Tersina Terza Tess Tessa Tessi Tessie Tessy Thalia Thea Theadora Theda Thekla Thelma Theo Theodora Theodosia Theresa Therese Theresina Theresita Theressa Therine Thia Thomasa Thomasin Thomasina Thomasine Tiena Tierney Tiertza Tiff Tiffani Tiffanie Tiffany Tiffi Tiffie Tiffy Tilda Tildi Tildie Tildy Tillie Tilly Tim Timi Timmi Timmie Timmy Timothea Tina Tine Tiphani Tiphanie Tiphany Tish Tisha Tobe Tobey Tobi Toby Tobye Toinette Toma Tomasina Tomasine Tomi Tommi Tommie Tommy Toni Tonia Tonie Tony Tonya Tonye Tootsie Torey Tori Torie Torrie Tory Tova Tove Tracee Tracey Traci Tracie Tracy Trenna Tresa Trescha Tressa Tricia Trina Trish Trisha Trista Trix Trixi Trixie Trixy Truda Trude Trudey Trudi Trudie Trudy Trula Tuesday Twila Twyla Tybi Tybie Tyne Ula Ulla Ulrica Ulrika Ulrikaumeko Ulrike Umeko Una Ursa Ursala Ursola Ursula Ursulina Ursuline Uta Val Valaree Valaria Vale Valeda Valencia Valene Valenka Valentia Valentina Valentine Valera Valeria Valerie Valery Valerye Valida Valina Valli Vallie Vally Valma Valry Van Vanda Vanessa Vania Vanna Vanni Vannie Vanny Vanya Veda Velma Velvet Venita Venus Vera Veradis Vere Verena Verene Veriee Verile Verina Verine Verla Verna Vernice Veronica Veronika Veronike Veronique Vevay Vi Vicki Vickie Vicky Victoria Vida Viki Vikki Vikky Vilhelmina Vilma Vin Vina Vinita Vinni Vinnie Vinny Viola Violante Viole Violet Violetta Violette Virgie Virgina Virginia Virginie Vita Vitia Vitoria Vittoria Viv Viva Vivi Vivia Vivian Viviana Vivianna Vivianne Vivie Vivien Viviene Vivienne Viviyan Vivyan Vivyanne Vonni Vonnie Vonny Vyky Wallie Wallis Walliw Wally Waly Wanda Wandie Wandis Waneta Wanids Wenda Wendeline Wendi Wendie Wendy Wendye Wenona Wenonah Whitney Wileen Wilhelmina Wilhelmine Wilie Willa Willabella Willamina Willetta Willette Willi Willie Willow Willy Willyt Wilma Wilmette Wilona Wilone Wilow Windy Wini Winifred Winna Winnah Winne Winni Winnie Winnifred Winny Winona Winonah Wren Wrennie Wylma Wynn Wynne Wynnie Wynny Xaviera Xena Xenia Xylia Xylina Yalonda Yasmeen Yasmin Yelena Yetta Yettie Yetty Yevette Ynes Ynez Yoko Yolanda Yolande Yolane Yolanthe Yoshi Yoshiko Yovonnda Ysabel Yvette Yvonne Zabrina Zahara Zandra Zaneta Zara Zarah Zaria Zarla Zea Zelda Zelma Zena Zenia Zia Zilvia Zita Zitella Zoe Zola Zonda Zondra Zonnya Zora Zorah Zorana Zorina Zorine Zsa Zsa Zsazsa Zulema ZuzanaFlask-Seeder-1.2.0/flask_seeder/data/domains/0000775000372000037200000000000013765161112021616 5ustar travistravis00000000000000Flask-Seeder-1.2.0/flask_seeder/data/domains/domains.txt0000664000372000037200000000032413765161026024014 0ustar travistravis00000000000000example.com flask-seeder.example flask-seeder.example.com flask-seeder.local flask-seeder.test flask.seeder.example flask.seeder.local flask.seeder.test seeder.example seeder.example.com seeder.local seeder.test Flask-Seeder-1.2.0/flask_seeder/cli.py0000775000372000037200000001236413765161026020411 0ustar travistravis00000000000000""" Module for seed cli subgroup $ FLASK_APP=app flask seed """ import os import re import importlib.util import inspect from itertools import groupby, chain import click from flask.cli import with_appcontext from flask import current_app as app from flask_seeder import Seeder def get_seed_scripts(root="seeds"): """ Get seed scripts Recursively walk a directory structure and find all python scripts. Arguments: root: Optional root directory to start walking (Default: "seeds") Returns: Returns a list with python file paths to found python scripts. If no files are found, and empty list is returned. """ extension = "py" result = [] for path, _, files in os.walk(root): for filename in files: if not re.search(r"\."+extension+"$", filename): continue # Concat the full file path file_path = os.path.join(path, filename) result.append(file_path) return result def inheritsfrom(child, parent): """ Verify inheritance Check if child inherits from parent. Does the same thing as built-in issubclass() except child and parent can't be the same class. Arguments: child: Child class parent: Parent class Returns: Returns True if Child inherits from Parent. Returns False if Child does not inherit from Parent or if Child and Parent is the same class. """ return issubclass(child, parent) and child != parent def load_seeder(cls, name, mod_path, file_path): """ Load seeder instance Instantiate a seeder using common base settings. Arguments: cls: Seeder class name: String name representation of the seeder mod_path: Python module path (package.module) file_path: Path to the python file in the file system Returns: Returns an instance of `cls`. """ seeder = cls() seeder.name = name seeder.mod_path = mod_path seeder.file_path = file_path return seeder def get_seeders_from_script(script): """ Get all seeders from a script file Reads a python script and detecs all classes within that inherits from the base Seeder class. Arguments: script: Filesystem path to the script Returns: Returns a list of loaded seeder objects from the script """ seeders = [] spec = importlib.util.spec_from_file_location("flask_seeder.seeder.ext", script) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) members = inspect.getmembers(module, inspect.isclass) for member in members: if inheritsfrom(member[1], Seeder): seeder = load_seeder(member[1], member[0], "", script) seeders.append(seeder) return seeders def get_seeders(root=None): """ Get all seeders from all scripts Finds all python scripts with seeders, loads them and return them. Returns: Ordered list of loaded seeder objects based on priority and class name """ seeders = [] if root is not None: scripts = get_seed_scripts(root=root) else: scripts = get_seed_scripts() for script in scripts: seeders.extend(get_seeders_from_script(script)) priority_key = lambda s: getattr(s, "priority", float("inf")) sorted_seeders = ( sorted(g, key=lambda s: type(s).__name__) for k, g in groupby(sorted(seeders, key=priority_key), key=priority_key) ) return chain.from_iterable(sorted_seeders) @click.group() def seed(): """ Database seed commands """ @seed.command("run") @click.option("--root", default="seeds", type=click.Path(), help="Root directory for seed scripts", envvar="FLASK_SEEDER_ROOT") @click.option("--commit/--no-commit", default=True, help="Commit changes to database after seeding", envvar="FLASK_SEEDER_AUTOCOMMIT") @click.argument("seeders", nargs=-1) @with_appcontext def seed_run(root, commit, seeders): """ Run database seeders Any optional arguments after the options will be treated as a list of seeders to run, for example: $ flask seed run DemoSeeder AnotherDemoSeeder """ click.echo("Running database seeders") db = None try: db = app.extensions["flask_seeder"].db except KeyError: raise RuntimeError("Flask-Seeder not initialized!") for seeder in get_seeders(root=root): if seeders and seeder.name not in seeders: continue seeder.db = db try: seeder.run() # pylint: disable=broad-except,invalid-name except Exception as e: click.echo("%s...\t[ERROR]" % seeder.name) click.echo("\t%s" % e) continue click.echo("%s...\t[OK]" % seeder.name) if not commit: click.echo("Not committing changes to database!") return click.echo("Committing to database!") db.session.commit() @seed.command("list") @click.option("--root", default="seeds", type=click.Path(), help="Root directory for seed scripts", envvar="FLASK_SEEDER_ROOT") def seed_list(root): """ List all discoverable seeders """ for seeder in get_seeders(root=root): click.echo("* %s" % seeder.name) Flask-Seeder-1.2.0/flask_seeder/parser.py0000664000372000037200000001602313765161026021127 0ustar travistravis00000000000000""" String Generator pattern parser """ import re TOKEN_MATCHERS = [ ("CHARCODE", r"\\([a-z])"), ("ONEOF", r"\[([a-zA-Z0-9]+)\]"), ("RANGE", r"\[(\w)-(\w)\]"), ("QUANTIFIER", r"\{(\d+)\}"), ("QUANTIFIER_RANGE", r"\{(\d*),(\d+)\}"), ("STRING_GROUP", r"\(([^|]([^)]+))\)"), ("NUMBER", r"\d+"), ("STRING", r"[a-zA-Z]+"), ("LITERAL", r"."), ] def strtype(string): """ Check string type Arguments: string: String to check Returns: Returns one of the following results * DIGIT: String is digit [0-9] * ALPHA: String is alpha [a-zA-Z] * STRING: If no other match is found, it is assumed to be a STRING type """ if str.isdigit(string): return "DIGIT" if str.isalpha(string): return "ALPHA" return "STRING" class Token: # pylint: disable=too-few-public-methods """ Token class Used by a tokenizer to store token data Attributes: group: Token group type or classification value: Token value pos: Starting position in input stream where token is found """ def __init__(self, group, value, pos=0): self.group = group self.value = value self.pos = pos class Tokenizer: """ String Generator Tokenizer Attributes: string: String to tokenize tokens: List of tokens after successful tokenization """ def __init__(self): self.tokens = [] self.regex = "|".join("(?P<%s>%s)" % matcher for matcher in TOKEN_MATCHERS) self._cursor = 0 def run(self, string=None): """ Run tokenizer """ for match in re.finditer(self.regex, string): group = match.lastgroup value = match.group() self.tokens.append(Token(group, value, match.start())) def next(self): """ Get next token Retrieve next token and move cursor forward. Returns: A Token instance """ if self._cursor >= len(self.tokens): return None token = self.tokens[self._cursor] self._cursor += 1 return token def peek(self): """ Peek at the next token Retrieve next token without moving cursor forward. Returns: A Token instance """ if self._cursor >= len(self.tokens): return None return self.tokens[self._cursor] class SGParser: """ String Generator Pattern parser """ def __init__(self, tokenizer=None): self.tokenizer = tokenizer def _repeat(self): ahead = self.tokenizer.peek() if ahead and ahead.group == "QUANTIFIER": result = self.parse_QUANTIFIER(self.tokenizer.next()) elif ahead and ahead.group == "QUANTIFIER_RANGE": result = self.parse_QUANTIFIER_RANGE(self.tokenizer.next()) else: result = {"type": "QUANTIFIER", "value": 1} return result def parse_STRING(self, token): # pylint: disable=invalid-name, no-self-use """ Parse a STRING token Returns: Dictionary representing the AST node structure for string """ return {"type": token.group, "value": token.value} def parse_RANGE(self, token): # pylint: disable=invalid-name """ Parse a RANGE token Returns: Dictionary representing the AST node structure for range """ (start, end) = re.search(r"\[([a-zA-Z0-9])-([a-zA-Z0-9])\]", token.value).groups() if start > end or strtype(start) != strtype(end): raise ValueError("Invalid range %s at position %d" % (token.value, token.pos)) result = {"type": token.group, "value": { "start": start, "end": end, }, "repeat": self._repeat()} return result def parse_QUANTIFIER(self, token): # pylint: disable=invalid-name, no-self-use """ Parse a QUANTIFIER token Returns: Dictionary representing the AST node structure for quantifier """ value = re.match(r"\{(\d+)\}", token.value).group(1) return {"type": token.group, "value": int(value)} def parse_CHARCODE(self, token): # pylint: disable=invalid-name """ Parse a CHARCODE token Returns: Dictionary representing the AST node structure for charcode """ value = re.match(r"\\([a-z])", token.value).group(1) return {"type": token.group, "value": value, "repeat": self._repeat()} def parse_ONEOF(self, token): # pylint: disable=invalid-name """ Parse a ONEOF token Returns: Dictionary representing the AST node structure for oneof """ values = re.findall("[a-zA-Z0-9]", token.value) return {"type": token.group, "value": values, "repeat": self._repeat()} def parse_QUANTIFIER_RANGE(self, token): # pylint: disable=invalid-name, no-self-use """ Parse a QUANTIFIER_RANGE token Returns: Dictionary representing the AST node structure for quantifier range """ (start, end) = re.search(r"\{(\d+),(\d+)\}", token.value).groups() if int(start) > int(end): raise ValueError("Invalid range %s at %d" % (token.value, token.pos)) return {"type": token.group, "value": {"start": int(start), "end": int(end)}} def parse_STRING_GROUP(self, token): # pylint: disable=invalid-name """ Parse a STRING_GROUP token Returns: Dictionary representing the AST node structure for string group """ options = re.match(r"\((.+)\)", token.value).group(1) values = re.split(r"\|", options) return {"type": token.group, "value": values, "repeat": self._repeat()} def parse_NUMBER(self, token): # pylint: disable=invalid-name """ Parse a NUMBER token Returns: Dictionary representing the AST node structure for number """ return {"type": token.group, "value": int(token.value), "repeat": self._repeat()} def parse_LITERAL(self, token): # pylint: disable=invalid-name, no-self-use """ Parse a LITERAL token Returns: Dictionary representing the AST node structure for literal """ return {"type": "LITERAL", "value": token.value} def parse(self, string): """ Main parser method Parses a list of tokens into an AST Arguments: string: The string to be parsed Returns: Dictionary representing the String Generator pattern AST """ ast = [] self.tokenizer.run(string) token = self.tokenizer.next() while token: function_name = "parse_" + token.group if not hasattr(self, function_name): function_name = "parse_LITERAL" func = getattr(self, function_name) ast.append(func(token)) token = self.tokenizer.next() return ast Flask-Seeder-1.2.0/flask_seeder/faker.py0000664000372000037200000000252213765161026020722 0ustar travistravis00000000000000""" Faker module """ from flask_seeder.generator import Generator # pylint: disable=too-few-public-methods class Faker: """ Base Faker class The `init` attribute is a dictionary that tells Faker how to initialize the classes, for example: { "name": generator.Name() } Attributes: cls: The type of class to be created init: Dictionary with initialization data """ def __init__(self, cls=None, init=None): """ Initialize faker """ self.cls = cls self.init = init def _init_args(self): args = {} if self.init is None: return args for arg, value in self.init.items(): if isinstance(value, Generator): args[arg] = value.generate() else: args[arg] = value return args def create(self, limit=1): """ Create objects Create a number of instance of `cls`, all initialized with data from `init`. Arguments: limit: How many objects to create, default 1. Returns: List of `cls` instances initialized with data from `init`. """ instances = [] for _ in range(limit): args = self._init_args() instances.append(self.cls(**args)) return instances Flask-Seeder-1.2.0/flask_seeder/generator.py0000664000372000037200000002207213765161026021622 0ustar travistravis00000000000000""" Generators module """ import uuid import random import pkg_resources from flask_seeder.parser import SGParser, Tokenizer def resource_path(path): """ Get the resource path Arguments: path: Relative path to the resource Returns: Returns the full filesystem path to the resource. Note that no validation is made to ensure the resource actually exist. """ return pkg_resources.resource_filename("flask_seeder", "data/" + path) def read_resource(path): """ Read resource text file Reads resource text file and returns content as a list. Arguments: path: The resource path relative to the data root directory Returns: A list with the file contents. """ lines = [] with open(resource_path(path)) as source: lines = source.read().splitlines() return lines def slicer(string, start, end): """ Slice a string Return a slice of the string matching anything between, and including, the `start` and `end` characters. Arguments: string: Original string start: Start character to begin slicing end: End character to stop slicing Returns: A new string which is a slice from the original string, including the start and end characters. None is return in case a valid slice couldn't be found, as in start or end characters are inversed or doesn't exist in the original slice. """ result = "" add = False for char in string: if char == start: add = True if add: result += char # Only return if we have found start if char == end and add: return result return None # pylint: disable=too-few-public-methods class Generator: """ Base Generator class Subclasses of Generator must implement the generate() method. Attributes: rnd: Access to python built-in random module ascii_characters: String with valid ascii characters integers: String with valid integers """ def __init__(self, rnd=None): self.rnd = rnd or random self.alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" self.digit = "0123456789" def generate(self): """ Generate data Must be implemented by subclasses """ raise NotImplementedError() # pylint: disable=too-few-public-methods class Integer(Generator): """ Random Integer generator """ def __init__(self, start=1, end=100, **kwargs): """ Initialize generator Arguments: start: Minimum value end: Maximum value """ super().__init__(**kwargs) self.start = start self.end = end def generate(self): """ Generate a random integer Set the start/end attributes prior to calling this method. Returns: A single random integer from `start` to `end`. """ return self.rnd.randint(self.start, self.end) class UUID(Generator): """ Random UUID generator """ def generate(self): """ Generate a random UUID """ return uuid.uuid4() class Email(Generator): """ Random Email generator """ def __init__(self, **kwargs): """ Initialize generator """ super().__init__(**kwargs) self._names = None self._domains = None def generate(self): """ Generate a random email address """ if self._names is None: self._names = read_resource("names/names.txt") if self._domains is None: self._domains = read_resource("domains/domains.txt") name = self.rnd.choice(self._names).lower() domain = self.rnd.choice(self._domains) return f"{name}@{domain}" class Sequence(Generator): """ Sequence integer generator """ def __init__(self, start=1, end=100, **kwargs): """ Initialize generator Arguments: start: Start of sequence end: End of sequence """ super().__init__(**kwargs) self._start = start self.end = end self._next = self.start @property def start(self): return self._start @start.setter def start(self, value): self._start = value if self._next < self._start: self._next = self._start def generate(self): """ Generate next integer in the sequence This method will raise a RuntimeError if the sequence has reached the end. """ value = self._next self._next += 1 if value > self.end: raise RuntimeError return value # pylint: disable=too-few-public-methods class Name(Generator): """ Random Name generator """ def __init__(self, **kwargs): super().__init__(**kwargs) self._lines = None def generate(self): """ Generate a random name Returns: A random name in string format """ if self._lines is None: self._lines = read_resource("names/names.txt") result = self.rnd.choice(self._lines) return result class String(Generator): """ Generate string from pattern This generator work by reading a pattern that describes how to generate the string. The pattern looks like a simplified regular expression but is processed completely different, so don't expect normal regular expressions to work. See docs for details. """ def __init__(self, pattern=None, parser=None, **kwargs): super().__init__(**kwargs) self.pattern = pattern self.parser = parser or self._create_parser() def _create_parser(self): # pylint: disable=no-self-use tokenizer = Tokenizer() return SGParser(tokenizer=tokenizer) def _range(self, quantifier): """ Create a range from quantifier There are two types of quantifiers QUANTIFIER: Repeat X times QUANTIFIER_RANGE: Repeat X times, where X is anywhere between start and end Returns: Python built in range() with a size depending on quantifier type. """ size = 1 if quantifier["type"] == "QUANTIFIER": size = quantifier["value"] elif quantifier["type"] == "QUANTIFIER_RANGE": start = quantifier["value"]["start"] end = quantifier["value"]["end"] size = self.rnd.choice(list(range(start, end+1))) return range(size) def generate_CHARCODE(self, node): # pylint: disable=invalid-name """ Generate CHARCODE string Generates a string depending on the CHARCODE: "c": Character/alpha "d": Digit """ result = "" for _ in self._range(node["repeat"]): if node["value"] == "c": result += self.rnd.choice(self.alpha) elif node["value"] == "d": result += self.rnd.choice(self.digit) else: raise ValueError("Invalid CHARCODE %s" % node["value"]) return result def generate_ONEOF(self, node): # pylint: disable=invalid-name """ Generate one from list Returns a value from a list of valid values """ result = "" for _ in self._range(node["repeat"]): result += self.rnd.choice(node["value"]) return result def generate_RANGE(self, node): # pylint: disable=invalid-name """ Generate a range of values Generates, in sequence, a number of alpha or digit characters. """ result = "" start = node["value"]["start"] end = node["value"]["end"] source = self.alpha if str.isdigit(start): source = self.digit for _ in self._range(node["repeat"]): choices = slicer(source, start, end) result += self.rnd.choice(choices) return result def generate_STRING_GROUP(self, node): # pylint: disable=invalid-name """ Generate a string form a list of strings """ result = "" for _ in self._range(node["repeat"]): result += self.rnd.choice(node["value"]) return result def generate_NUMBER(self, node): # pylint: disable=invalid-name """ Generate number literal """ result = "" for _ in self._range(node["repeat"]): result += str(node["value"]) return result def generate_STRING(self, node): # pylint: disable=invalid-name, no-self-use """ Generate string literal """ return node["value"] def generate_LITERAL(self, node): # pylint: disable=invalid-name, no-self-use """ Generate literal """ return node["value"] def generate(self): """ Generate a string based on pattern """ ast = self.parser.parse(self.pattern) result = "" for node in ast: function_name = "generate_" + node["type"] if not hasattr(self, function_name): raise NotImplementedError("Unknown node type %s" % node["type"]) func = getattr(self, function_name) result += func(node) return result Flask-Seeder-1.2.0/flask_seeder/__init__.py0000775000372000037200000000235513765161026021400 0ustar travistravis00000000000000""" Flask-Seeder """ from .seeder import Seeder from .faker import Faker # pylint: disable=too-few-public-methods class SeedConfig: """ Seed config stored in Flask This is intended to be stored as an instance inside a Flask app for access to Flask-Seed configuration. """ def __init__(self, db): self.db = db # pylint: disable=too-few-public-methods class FlaskSeeder: """ Flask extension Flask-Seeder Usage: seeder = FlaskSeeder() seeder.init_app(app, db) """ def __init__(self, app=None, db=None): """ Initialize FlaskSeeder Arguments: app: Flask app db: SQLAlchemy database object """ self.app = app self.db = db if app is not None and db is not None: self.init_app(app, db) def init_app(self, app, db=None): """ Initialize app after construction Initialize Flask-Seeder and register as an extension with Flask Arguments: app: Flask app db: SQLAlchemy database object """ self.db = db or self.db if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['flask_seeder'] = SeedConfig(self.db) Flask-Seeder-1.2.0/.coveragerc0000775000372000037200000000012413765161026016751 0ustar travistravis00000000000000[run] omit = */__init__.py tests/* setup.py include = flask_seeder/* Flask-Seeder-1.2.0/setup.py0000775000372000037200000000151513765161026016347 0ustar travistravis00000000000000import setuptools with open("README.md", "r") as fh: long_description = fh.read() setuptools.setup( name="Flask-Seeder", version="1.2.0", url="https://github.com/diddi-/flask-seeder", author="Diddi Oskarsson", author_email="diddi@diddi.se", description="Flask extension to seed database through scripts", long_description=long_description, long_description_content_type="text/markdown", packages=setuptools.find_packages(), include_package_data=True, license="MIT", install_requires=[ "Flask>=1.0.2", ], classifiers=[ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ], entry_points={ "flask.commands": [ "seed=flask_seeder.cli:seed", ] } ) Flask-Seeder-1.2.0/tests/0000775000372000037200000000000013765161112015766 5ustar travistravis00000000000000Flask-Seeder-1.2.0/tests/generator/0000775000372000037200000000000013765161112017754 5ustar travistravis00000000000000Flask-Seeder-1.2.0/tests/generator/test_sequence.py0000664000372000037200000000174013765161026023203 0ustar travistravis00000000000000from unittest import TestCase from unittest.mock import MagicMock from flask_seeder.generator import Sequence class TestSequenceGenerator(TestCase): def setUp(self): self.rnd_mock = MagicMock() self.generator = Sequence(rnd=self.rnd_mock) def test_generate_sequential_numbers(self): first = self.generator.generate() second = self.generator.generate() self.assertTrue(first+1 == second) def test_generate_sequential_start_end(self): self.generator.start = 23 self.generator.end = 25 first = self.generator.generate() second = self.generator.generate() self.assertEqual(first, 23) self.assertEqual(second, 24) def test_generate_raise_RuntimeError_when_exhausted(self): # Make start larger than end to trigger RuntimeError self.generator.start = 10 self.generator.end = 5 with self.assertRaises(RuntimeError): self.generator.generate()Flask-Seeder-1.2.0/tests/generator/test_integer.py0000664000372000037200000000137113765161026023030 0ustar travistravis00000000000000from unittest import TestCase from unittest.mock import MagicMock from flask_seeder.generator import Integer class TestIntegerGenerator(TestCase): def setUp(self): self.rnd_mock = MagicMock() self.generator = Integer(rnd=self.rnd_mock) def test_generate_int_with_default_values(self): self.generator.generate() self.rnd_mock.randint.assert_called_once_with( self.generator.start, self.generator.end ) def test_generate_int_with_custom_values(self): self.generator.start = 10 self.generator.end = 20 self.generator.generate() self.rnd_mock.randint.assert_called_once_with( self.generator.start, self.generator.end )Flask-Seeder-1.2.0/tests/generator/test_string.py0000664000372000037200000000661213765161026022704 0ustar travistravis00000000000000from unittest import TestCase from unittest.mock import MagicMock, patch from flask_seeder.generator import String class TestStringGenerator(TestCase): def setUp(self): self.generator = String() def test_integer_range_produce_character_from_valid_range(self): m_rnd = MagicMock() self.generator.rnd = m_rnd self.generator.pattern = "[4-6]" self.generator.generate() m_rnd.choice.assert_called_once_with("456") def test_string_range_produce_character_from_valid_range(self): m_rnd = MagicMock() self.generator.rnd = m_rnd self.generator.pattern = "[i-o]" self.generator.generate() m_rnd.choice.assert_called_once_with("ijklmno") def test_integer_range_pattern(self): self.generator.pattern = "[0-9]" string = self.generator.generate() self.assertRegex(string, r"^\d$") def test_string_range_pattern(self): self.generator.pattern = "[a-z]" string = self.generator.generate() self.assertRegex(string, "^[a-z]$") def test_range_pattern_quantifier(self): self.generator.pattern = "[0-9]{5}" string = self.generator.generate() self.assertRegex(string, r"^\d{5}$") def test_multiple_range_patterns(self): self.generator.pattern = "[0-9][a-c]" string = self.generator.generate() self.assertRegex(string, r"^\d[a-c]$") def test_multiple_range_patterns_with_quantifiers(self): self.generator.pattern = "[0-9]{4}[x-z]{2}" string = self.generator.generate() self.assertRegex(string, r"^\d{4}[x-z]{2}$") def test_integer_character_code(self): self.generator.pattern = r"\d" string = self.generator.generate() self.assertRegex(string, r"^\d$") def test_string_character_code(self): self.generator.pattern = r"\c" string = self.generator.generate() self.assertRegex(string, "^[a-zA-Z]$") def test_character_code_with_quantifier(self): self.generator.pattern = r"\d{3}" string = self.generator.generate() self.assertRegex(string, r"^\d{3}$") def test_oneof_pattern(self): self.generator.pattern = r"[aoueiy]" string = self.generator.generate() self.assertRegex(string, "^[aoueiy]$") def test_oneof_pattern_with_quantifier(self): self.generator.pattern = r"[aoueiy]{3}" string = self.generator.generate() self.assertRegex(string, "^[aoueiy]{3}$") def test_complex_string_generation(self): self.generator.pattern = r"abc\d{4}[i-m]{2}[qwerty]xyz" string = self.generator.generate() self.assertRegex(string, r"^abc\d{4}[i-m]{2}[qwerty]xyz$") def test_charcode_with_quantifier_range(self): self.generator.pattern = r"\c{1,2}" string = self.generator.generate() self.assertRegex(string, "[a-zA-Z]{1,2}") def test_invalid_charcode_raise_ValueError(self): self.generator.pattern = r"\q" with self.assertRaises(ValueError): self.generator.generate() def test_string_group(self): self.generator.pattern = r"(one|two)" string = self.generator.generate() self.assertRegex(string, r"(one|two)") def test_number(self): self.generator.pattern = r"123" string = self.generator.generate() self.assertEqual(string, "123") Flask-Seeder-1.2.0/tests/generator/test_name.py0000664000372000037200000000105513765161026022312 0ustar travistravis00000000000000from unittest import TestCase from unittest.mock import MagicMock, mock_open, patch from flask_seeder.generator import Name MOCK_CONTENTS = [ "name1", "name2" ] class TestNameGenerator(TestCase): def setUp(self): self.rnd_mock = MagicMock() self.generator = Name(rnd=self.rnd_mock) @patch("flask_seeder.generator.read_resource", return_value=MOCK_CONTENTS) def test_generate_name(self, m_read_resource): result = self.generator.generate() self.rnd_mock.choice.assert_called_once_with(MOCK_CONTENTS) Flask-Seeder-1.2.0/tests/generator/test_generator.py0000664000372000037200000000270413765161026023362 0ustar travistravis00000000000000from unittest import TestCase from unittest.mock import MagicMock, patch, mock_open from flask_seeder.generator import Generator, resource_path, read_resource, slicer MOCK_CONTENTS = "line1\nline2" class TestGenerator(TestCase): def setUp(self): self.rnd_mock = MagicMock() self.generator = Generator(rnd=self.rnd_mock) def test_generate_raise_NotImplementedError(self): with self.assertRaises(NotImplementedError): self.generator.generate() @patch("flask_seeder.generator.pkg_resources") def test_resource_path(self, m_pkg): resource_path("test") m_pkg.resource_filename.assert_called_once() @patch("flask_seeder.generator.resource_path", return_value="test") @patch("flask_seeder.generator.open", mock_open(read_data=MOCK_CONTENTS)) def test_read_resource_return_contents_as_list(self, m_open): expected = [ "line1", "line2" ] result = read_resource("test") self.assertListEqual(result, expected) def test_slicer_return_new_string(self): original = "abcdefghijklmnopqrstuvwxyz" expected = "ijklmno" result = slicer(original, "i", "o") self.assertEqual(result, expected) def test_slicer_return_None_if_no_slice_is_found(self): original = "abcdefghijklmnopqrstuvwxyz" # Inversed start/end result = slicer(original, "z", "a") self.assertIsNone(result) Flask-Seeder-1.2.0/tests/generator/__init__.py0000664000372000037200000000000013765161026022057 0ustar travistravis00000000000000Flask-Seeder-1.2.0/tests/generator/test_uuid.py0000664000372000037200000000102713765161026022337 0ustar travistravis00000000000000import uuid from unittest import TestCase from unittest.mock import MagicMock, patch from flask_seeder.generator import UUID class TestUUIDGenerator(TestCase): def setUp(self): self.generator = UUID() @patch("uuid.uuid4", return_value=0) def test_generate_mock_uuid(self, m_uuid): result = self.generator.generate() assert result == 0 def test_generate_uuid(self): result = self.generator.generate() self.assertEqual(4, uuid.UUID(str(result), version=4).version) Flask-Seeder-1.2.0/tests/generator/test_email.py0000664000372000037200000000165013765161026022462 0ustar travistravis00000000000000from unittest import TestCase from unittest.mock import MagicMock, mock_open, patch, call from flask_seeder.generator import Email MOCK_DOMAINS = [ "domain1.com", ] MOCK_NAMES = [ "test1", ] def read_resource(arg): if arg == "domains/domains.txt": return MOCK_DOMAINS if arg == "names/names.txt": return MOCK_NAMES class TestEmailGenerator(TestCase): def setUp(self): self.rnd_mock = MagicMock( choice=MagicMock(side_effect=lambda values: values[0]) ) self.generator = Email(rnd=self.rnd_mock) @patch("flask_seeder.generator.read_resource", side_effect=read_resource) def test_generate_email(self, m_read_resource): result = self.generator.generate() self.rnd_mock.choice.assert_has_calls( [call(MOCK_NAMES), call(MOCK_DOMAINS)], any_order=True ) assert result == f"{MOCK_NAMES[0]}@{MOCK_DOMAINS[0]}" Flask-Seeder-1.2.0/tests/test_faker.py0000664000372000037200000000204213765161026020471 0ustar travistravis00000000000000from unittest import TestCase from flask_seeder import Faker from flask_seeder.generator import Generator class Dummy: def __init__(self, test_arg=None): self.test_arg = test_arg class TestFaker(TestCase): def setUp(self): self.faker = Faker(cls=Dummy) def test_create_return_instance(self): result = self.faker.create() self.assertIsInstance(result[0], Dummy) def test_create_with_limit(self): result = self.faker.create(2) self.assertEqual(len(result), 2) def test_create_instantiate_with_init_args_value(self): self.faker.init = {"test_arg": "test_value"} result = self.faker.create() self.assertEqual(result[0].test_arg, "test_value") def test_create_run_init_args_generator(self): class DummyGenerator(Generator): def generate(self): return "test_value" self.faker.init = {"test_arg": DummyGenerator()} result = self.faker.create() self.assertEqual(result[0].test_arg, "test_value") Flask-Seeder-1.2.0/tests/test_seeder.py0000775000372000037200000000043313765161026020655 0ustar travistravis00000000000000from unittest import TestCase from flask_seeder import Seeder class TestBaseSeeder(TestCase): def setUp(self): self.seeder = Seeder() def test_run_raise_NotImplementedError(self): with self.assertRaises(NotImplementedError): self.seeder.run() Flask-Seeder-1.2.0/tests/parser/0000775000372000037200000000000013765161112017262 5ustar travistravis00000000000000Flask-Seeder-1.2.0/tests/parser/test_parser.py0000664000372000037200000002477413765161026022211 0ustar travistravis00000000000000from unittest import TestCase from unittest.mock import MagicMock from flask_seeder.parser import SGParser, Token, strtype class TestUtility(TestCase): def test_strtype_return_DIGIT_type(self): result = strtype("123") self.assertEqual(result, "DIGIT") def test_strtype_return_ALPHA_type(self): result = strtype("abc") self.assertEqual(result, "ALPHA") def test_strtype_return_STRING_type(self): result = strtype("abc123#.}") self.assertEqual(result, "STRING") class TestSGParser(TestCase): def setUp(self): self.tokenizer = MagicMock() self.parser = SGParser(tokenizer=self.tokenizer) def test_parse_string(self): expected = {"type": "STRING", "value": "qwerty"} token = Token("STRING", "qwerty") result = self.parser.parse_STRING(token) self.assertDictEqual(result, expected) def test_parse_range(self): expected = {"type": "RANGE", "value": {"start": "1", "end": "2"}, "repeat": { "type": "QUANTIFIER", "value": 1, }} token = Token("RANGE", "[1-2]") result = self.parser.parse_RANGE(token) self.assertDictEqual(result, expected) def test_parse_range_raise_RuntimeError_for_inversed_range(self): token = Token("RANGE", "[2-1]") with self.assertRaises(ValueError): self.parser.parse_RANGE(token) def test_prase_range_raise_RuntimeError_for_mixed_start_end(self): token = Token("RANGE", "[1-z]") with self.assertRaises(ValueError): self.parser.parse_RANGE(token) def test_parse_quantifier(self): expected = {"type": "QUANTIFIER", "value": 5} token = Token("QUANTIFIER", "{5}") result = self.parser.parse_QUANTIFIER(token) self.assertDictEqual(result, expected) def test_parse_range_with_quantifier(self): expected = {"type": "RANGE", "value": { "start": "1", "end": "2" }, "repeat": { "type": "QUANTIFIER", "value": 5 }} range_token = Token("RANGE", "[1-2]") quant_token = Token("QUANTIFIER", "{5}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_RANGE(range_token) self.assertDictEqual(result, expected) def test_parse_range_with_quantifier_range(self): expected = {"type": "RANGE", "value": { "start": "1", "end": "2" }, "repeat": { "type": "QUANTIFIER_RANGE", "value": { "start": 5, "end": 10 } }} range_token = Token("RANGE", "[1-2]") quant_token = Token("QUANTIFIER_RANGE", "{5,10}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_RANGE(range_token) self.assertDictEqual(result, expected) def test_parse_charcode(self): expected = {"type": "CHARCODE", "value": "d", "repeat": { "type": "QUANTIFIER", "value": 1, }} token = Token("CHARCODE", r"\d") result = self.parser.parse_CHARCODE(token) self.assertDictEqual(result, expected) def test_parse_charcode_with_quantifier(self): expected = {"type": "CHARCODE", "value": "d", "repeat": { "type": "QUANTIFIER", "value": 2}} range_token = Token("CHARCODE", r"\d") quant_token = Token("QUANTIFIER", "{2}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_CHARCODE(range_token) self.assertDictEqual(result, expected) def test_parse_charcode_with_quantifier_range(self): expected = {"type": "CHARCODE", "value": "d", "repeat": { "type": "QUANTIFIER_RANGE", "value": { "start": 5, "end": 10 } }} range_token = Token("CHARCODE", r"\d") quant_token = Token("QUANTIFIER_RANGE", "{5,10}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_CHARCODE(range_token) self.assertDictEqual(result, expected) def test_parse_oneof(self): expected = {"type": "ONEOF", "value": ["a", "b", "c"], "repeat": { "type": "QUANTIFIER", "value": 1, }} token = Token("ONEOF", "[abc]") result = self.parser.parse_ONEOF(token) self.assertDictEqual(result, expected) def test_parse_oneof_with_quantifier(self): expected = {"type": "ONEOF", "value": ["a", "b", "c"], "repeat": { "type": "QUANTIFIER", "value": 2 }} range_token = Token("ONEOF", "[abc]") quant_token = Token("QUANTIFIER", "{2}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_ONEOF(range_token) self.assertDictEqual(result, expected) def test_parse_oneof_with_quantifier_range(self): expected = {"type": "ONEOF", "value": ["a", "b", "c"], "repeat": { "type": "QUANTIFIER_RANGE", "value": { "start": 5, "end": 10 } }} range_token = Token("ONEOF", "[abc]") quant_token = Token("QUANTIFIER_RANGE", "{5,10}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_ONEOF(range_token) self.assertDictEqual(result, expected) def test_parse_quantifier_range(self): expected = {"type": "QUANTIFIER_RANGE", "value": {"start": 1, "end": 2}} token = Token("QUANTIFIER_RANGE", "{1,2}") result = self.parser.parse_QUANTIFIER_RANGE(token) self.assertDictEqual(result, expected) def test_parse_quantifier_range_raise_RuntimeError_for_inversed_range(self): token = Token("QUANTIFIER_RANGE", "{2,1}") with self.assertRaises(ValueError): self.parser.parse_QUANTIFIER_RANGE(token) def test_parse_string_group(self): expected = {"type": "STRING_GROUP", "value": ["one", "two", "three"], "repeat": { "type": "QUANTIFIER", "value": 1, }} token = Token("STRING_GROUP", "(one|two|three)") result = self.parser.parse_STRING_GROUP(token) self.assertDictEqual(result, expected) def test_parse_string_group_with_quantifier(self): expected = {"type": "STRING_GROUP", "value": ["one", "two"], "repeat": { "type": "QUANTIFIER", "value": 3 }} range_token = Token("STRING_GROUP", "(one|two)") quant_token = Token("QUANTIFIER", "{3}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_STRING_GROUP(range_token) self.assertDictEqual(result, expected) def test_parse_string_group_with_quantifier_range(self): expected = {"type": "STRING_GROUP", "value": ["one", "two"], "repeat": { "type": "QUANTIFIER_RANGE", "value": { "start": 5, "end": 10 } }} range_token = Token("STRING_GROUP", "(one|two)") quant_token = Token("QUANTIFIER_RANGE", "{5,10}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_STRING_GROUP(range_token) self.assertDictEqual(result, expected) def test_parse_number(self): expected = {"type": "NUMBER", "value": 123, "repeat": { "type": "QUANTIFIER", "value": 1, }} token = Token("NUMBER", "123") result = self.parser.parse_NUMBER(token) self.assertDictEqual(result, expected) def test_parse_number_with_quantifier(self): expected = {"type": "NUMBER", "value": 123, "repeat": { "type": "QUANTIFIER", "value": 3 }} range_token = Token("NUMBER", "123") quant_token = Token("QUANTIFIER", "{3}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_NUMBER(range_token) self.assertDictEqual(result, expected) def test_parse_number_with_quantifier_range(self): expected = {"type": "NUMBER", "value": 123, "repeat": { "type": "QUANTIFIER_RANGE", "value": { "start": 5, "end": 10 } }} range_token = Token("NUMBER", "123") quant_token = Token("QUANTIFIER_RANGE", "{5,10}") self.tokenizer.peek.return_value = quant_token self.tokenizer.next.return_value = quant_token result = self.parser.parse_NUMBER(range_token) self.assertDictEqual(result, expected) def test_parse_literal(self): expected = {"type": "LITERAL", "value": "#(]"} token = Token("LITERAL", "#(]") result = self.parser.parse_LITERAL(token) self.assertDictEqual(result, expected) Flask-Seeder-1.2.0/tests/parser/__init__.py0000664000372000037200000000000013765161026021365 0ustar travistravis00000000000000Flask-Seeder-1.2.0/tests/parser/test_tokenizer.py0000664000372000037200000000410113765161026022705 0ustar travistravis00000000000000from unittest import TestCase from flask_seeder.parser import Tokenizer class TestTokenizer(TestCase): def setUp(self): self.t = Tokenizer() def test_tokenize_CHARCODE(self): self.t.run(r"\d") self.assertEqual(self.t.next().group, "CHARCODE") def test_tokenize_ONEOF(self): self.t.run("[abc]") self.assertEqual(self.t.next().group, "ONEOF") def test_tokenize_RANGE(self): self.t.run("[0-9]") self.assertEqual(self.t.next().group, "RANGE") def test_tokenize_QUANTIFIER(self): self.t.run("{1}") self.assertEqual(self.t.next().group, "QUANTIFIER") def test_tokenize_QUANTIFIER_RANGE(self): self.t.run("{1,5}") self.assertEqual(self.t.next().group, "QUANTIFIER_RANGE") def test_tokenize_STRING_GROUP(self): self.t.run("(one|two|three)") self.assertEqual(self.t.next().group, "STRING_GROUP") def test_tokenize_NUMBER(self): self.t.run("123") self.assertEqual(self.t.next().group, "NUMBER") def test_tokenize_STRING(self): self.t.run("string") self.assertEqual(self.t.next().group, "STRING") def test_tokenize_LITERAL(self): self.t.run("]#!.") self.assertEqual(self.t.next().group, "LITERAL") def test_tokenize_combination(self): expected = [ "STRING", "RANGE", "QUANTIFIER", "CHARCODE", "STRING_GROUP", "QUANTIFIER_RANGE", "ONEOF", "QUANTIFIER", "NUMBER" ] self.t.run("abc[0-9]{5}\\d(one|two){1,2}[qwerty]{2}123") groups = [grp.group for grp in self.t.tokens] self.assertListEqual(groups, expected) def test_next_return_None_when_no_tokens_remain(self): self.assertIsNone(self.t.next()) def test_peek_return_None_when_no_tokens_remain(self): self.assertIsNone(self.t.peek()) def test_peek_return_next_token_without_moving_cursor(self): self.t.run("abc") self.assertEqual(self.t.peek(), self.t.peek()) Flask-Seeder-1.2.0/tests/test_flask_seeder.py0000664000372000037200000000100513765161026022026 0ustar travistravis00000000000000from unittest import TestCase from unittest.mock import MagicMock from flask_seeder import FlaskSeeder class TestFlaskSeeder(TestCase): def test_init_app_without_db(self): """ FlaskSeeder should use db object when passed via constructor. """ db = MagicMock() app = MagicMock() ext = {} app.extensions.__setitem__.side_effect = ext.__setitem__ seeder = FlaskSeeder(db=db) seeder.init_app(app) self.assertEqual(ext["flask_seeder"].db, db) Flask-Seeder-1.2.0/tests/test_cli.py0000775000372000037200000001046413765161026020162 0ustar travistravis00000000000000import os from unittest import TestCase from unittest.mock import patch, MagicMock from flask import Flask from flask_seeder import cli, FlaskSeeder from flask_seeder import Seeder # This is for mocking os.walk, returns a list with dirs and files # [ , [], [] ] MOCK_FILES = [ ["data", ["sub1", "sub2"], []], [os.path.join("data", "sub1"), [], ["file1.py", "file2.py"]], [os.path.join("data", "sub2"), [], ["file3.py", "file4.py"]], ] class TestSeedCLI(TestCase): def setUp(self): self.db_mock = MagicMock() self.app = Flask("test") self.cli = self.app.test_cli_runner() self.seeder = FlaskSeeder() self.seeder.init_app(self.app, db=self.db_mock) @patch("flask_seeder.cli.os.walk", return_value=MOCK_FILES) def test_get_seed_scripts_return_list_of_modules(self, mocked): expected_result = [ os.path.join("data", "sub1", "file1.py"), os.path.join("data", "sub1", "file2.py"), os.path.join("data", "sub2", "file3.py"), os.path.join("data", "sub2", "file4.py"), ] modules = cli.get_seed_scripts() self.assertListEqual(modules, expected_result) @patch("flask_seeder.cli.get_seeders") def test_seeder_calls_run_method_on_loaded_modules(self, m_get_seeders): m_seeder = MagicMock() m_get_seeders.return_value = [m_seeder] self.cli.invoke(cli.seed_run) m_seeder.run.assert_called_once() @patch("flask_seeder.cli.get_seed_scripts", return_value=["test"]) @patch("flask_seeder.cli.get_seeders_from_script") def test_get_seeders_return_ordered_iterable_of_seeders(self, m_get_seeders, m_get_scripts): class TestSeeder: def __init__(self, priority=None): if priority: self.priority = priority class QQTestSeeder: def __init__(self, priority=None): if priority: self.priority = priority unordered_seeder_list = [TestSeeder(10), QQTestSeeder(), TestSeeder(), QQTestSeeder(1)] m_get_seeders.return_value = unordered_seeder_list expected_result = [ unordered_seeder_list[3], unordered_seeder_list[0], unordered_seeder_list[1], unordered_seeder_list[2] ] result = list(cli.get_seeders()) self.assertListEqual(result, expected_result) @patch("flask_seeder.cli.get_seeders") def test_seed_list_print_list_of_seeders(self, m_get_seeders): m_seeder = MagicMock() m_seeder.name = "testseeder" m_get_seeders.return_value = [m_seeder] result = self.cli.invoke(cli.seed_list) self.assertTrue("testseeder" in result.output) @patch("flask_seeder.cli.get_seeders") def test_seed_run_echo_failed_runs(self, m_get_seeders): class TestSeeder(Seeder): def run(self): raise ValueError() m_get_seeders.return_value = [TestSeeder()] result = self.cli.invoke(cli.seed_run) self.assertTrue("ERROR" in result.output) @patch("flask_seeder.cli.get_seeders") def test_root_option_with_list(self, m_get_seeders): self.cli.invoke(cli.seed_list, args=["--root", "sub1"]) m_get_seeders.assert_called_once_with(root="sub1") @patch("flask_seeder.cli.get_seeders") def test_root_option_with_run(self, m_get_seeders): self.cli.invoke(cli.seed_run, args=["--root", "sub1"]) m_get_seeders.assert_called_once_with(root="sub1") @patch("flask_seeder.cli.get_seeders") def test_run_with_seeder_argument(self, m_get_seeders): m_seeder = MagicMock() m_seeder.name = "TestSeeder" m_get_seeders.return_value = [m_seeder] self.cli.invoke(cli.seed_run, args=["TestSeeder"]) m_seeder.run.assert_called_once() @patch("flask_seeder.cli.get_seeders", return_value=[]) def test_run_commit_session_by_default(self, m_get_seeders): self.cli.invoke(cli.seed_run) self.db_mock.session.commit.assert_called() @patch("flask_seeder.cli.get_seeders", return_value=[]) def test_run_avoid_commit_with_no_commit_option(self, m_get_seeders): self.cli.invoke(cli.seed_run, args=["--no-commit"]) self.assertFalse(self.db_mock.session.commit.called) Flask-Seeder-1.2.0/tests/__init__.py0000775000372000037200000000000013765161026020074 0ustar travistravis00000000000000