v9.1.2

• Fixed a bug with v9.1.0 and v9.1.1 where type information was not exposed

v9.1.1

• Fixes a regression with v9.1.0 where subpackages where missing on install

v9.1.0

New Features

• Added manim as an optional dependency along with functions for generating animations of DFAs and NFAs reading strings (#252)
• Added an example jupyter notebook for DFAs (#234)
• Various improvements to the build tools and configuration; please see the Contributing guide for details on how to migrate (#260, #254, #253, #254, #262)

Bugfixes

• Fix warnings on build commands (#255)
• Fix a bug where converted partial DFAs were not always equivalent (#257)
• Make the results of the to_regex method deterministic (#231)

v9.0.0

Breaking Changes

• Python 3.8 support has been dropped. Please upgrade to Python 3.9 or later to use Automata v9. (#243)

New Features

• All Unicode characters are now supported in regular expressions (#233)
• Simplified developer dependencies by migrating from black/flake8/isort to Ruff (#243)

Bugfixes

• Fixed bug in MNTM.read_input_as_ntm() (#239)

v8.4.0

A minor release with updates from the recently-completed pyOpenSci review:
pyOpenSci/software-submission#152

New Features

• Added length limits to the successor family of functions

Fixes

• Fixed addition of unreachable states for some cases in the creation of partial DFAs, and made behavior more consistent (#228)
• Fixed bug in edge case for minify (#218)

Documentation

• Added documentation making the library easier to use for new users, with more detailed examples

v8.3.0

Notable Changes

• Added a new DFA.from_substrings method using the Aho-Corasick algorithm (#167)
• Fixed support for Python 3.12
• The contributing guide has been reworked with clearer information on how you can contribute to the Automata library!

Miscellaneous

• Various minor bugfixes in the codebase
• Updated dev dependencies to latest (non-breaking) versions
• Fixed the performance of DFA.maximum_word_length (#202 and #205)

v8.2.0

New Features

• Added a show_diagram method for Push Down Automata (#177)

New Documentation Site!

• The Automata documentation has moved to a brand new documentation website with better navigation and a new search capability that should greatly improve the experience. Check it out at https://caleb531.github.io/automata/

Fixes

• Fixed the handling of the quantifier pattern in regular expressions by switching from greedy matching (*) to lazy matching (*?) (#181)

v8.1.0

New Features

• Added an optional minify step (default-enabled) to the DFA.to_partial() method

Announcements

• We are currently in the process of submitting the Automata project to the Journal of Open Source Software (JOSS), which will introduce the project to a broader community of research using open source software
  • Please see here for the status of the approval process
  • You can read the full paper itself here

v8.0.0

Automata v8 is a performance and polish-focused release, providing improvements
under the hood that should improve the quality of life for most package users.

Huge thanks to @khoda81, and @EduardoGoulart1 for the new features in this release!

New Features

Jupyter Notebook Integration (#129)

All finite automata (subclasses of the FA class) now have native support for diagram
creation in Jupyter notebooks! This is enabled by installing the optional visual dependency, which includes the
pygraphviz and coloraide dependencies used in the show_diagram() methods for DFAs/NFAs.
The styling for the diagrams has been changed from previous releases and is
modeled after the diagrams used in the
visual automata package.

The show_diagram() now returns an AGraph corresponding to the given FA,
and the FA will render a diagram automatically inside of a Juyter notebook. See the
FA documentation for more details.

Type Hints (#131)

Type annotations have been added to the library, providing greater information
when using code completion tools like Pylance. This also makes it easier to type-check
application code using the library.

Better Partial DFA Support (#147)

Methods in the DFA class now have greater support for partial DFAs (ones with
some missing transitions), including support for more efficient binary operations
with partial DFAs. Partial DFAs have smaller description complexity, and thus
some algorithms are more efficient when operating on them.

In addition, the from_prefix, from_finite_language, and from_nfa DFA creation
functions now return partial DFAs by default. The new to_partial and to_complete
methods can be used to convert a DFA into an equivalent partial or complete DFA
respectively.

my_dfa.to_partial()  # get equivalent partial DFA
my_dfa.to_complete()  # get equivalent partial DFA

Please see the DFA documentation for the full details on these new
methods (outlined below).

Smaller Changes

Regex Changes

• Quantifiers were added to the regular expression parsing, representing the repetition
  of the preceding expression. For example, the regex a{1,2} would match a between 1
  and 2 times (#121).
• A pair of parenthesis () can now be used to represent the empty string (#136).
• The default set of input symbols for NFA.from_regex was changed to all ascii letters and digits (#121).
• State names of NFAs constructed from regexes no longer persist between runs of the regex engine (#130).

Pickling Support (#125)

All automata now natively support pickling.

Examples (#146)

A section has been added to the documentation demonstrating example uses of the package, can
be found here.

Breaking Changes

Dependency Changes

Python 3.7 support has been dropped. Please upgrade to Python 3.8 or later to
use Automata v8.

Diagrams are no longer being generated using pydot; this dependency has been
dropped in favor of using the visual optional dependency, which will install
pygraphviz and coloraide used for generating figures. You should install
this optional dependency if you wish to generate figures. This change was to
allow for native support for displaying finite automaton in Jupyter notebooks.
The style of the diagrams has been lifted from the visual automata package,
so you should take a look at the diagrams generated and see if they are still
satisfactory.

Other new dependencies have been added, but these will be installed automatically
along with v8 of the package.

Greater Support for Partial DFAs

There is now greater support for partial DFAs, which included changing the
DFA.from_nfa() function to return a partial DFA instead of a complete one.
To obtain a complete DFA, you must now call DFA.from_nfa().to_complete(trap_state_name),
where trap_state_name will be used as the name for a trap state if one needs to
be added.

Type Hints

Type hints have now been added, meaning that code which previously called functions
with incorrect types may not have been flagged. See output from your typechecker
for more information.

NFA.from_regex default input symbols

The default set of input symbols for NFA.from_regex was changed to all ASCII letters and digits.
If needing to use a specific set of input symbols, use the input_symbols parameter.

v7.1.0

• Added new enable_mutable_automata global configuration option if you need to maximize the performance of automaton creation
  • See the documentation for the Automaton class
• Optimizations to automaton creation even if you leave immutable automata enabled
• Added a new Shuffle operator (denoted with the caret symbol ^) for regular expressions (e.g. a^b represents all permutations of a and b) (#112)
• Fixed a bug with the conversion from GNFA to regular expression (#122 and #123)
• Minor improvements to the error messaging for the automata.regex.parser module
• Other small optimizations and improvements