| Name | automython JSON |
| Version |
1.2.0
JSON |
| download |
| home_page | https://github.com/mkantrr/automython |
| Summary | A simplistic programming language interpreter to Python to help students grasp finite automata theory programmatically and with a computed graph through visualization libraries. |
| upload_time | 2024-04-03 19:20:19 |
| maintainer | None |
| docs_url | None |
| author | Matthew Kanter |
| requires_python | >=3.8 |
| license | The MIT License (MIT) Copyright (c) 2024 Matthew Kanter Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| keywords |
automata
finite
compiler
interpreter
theory
computational theory
non-deterministic
turing
machine
state
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# Automython (v1.2.0)
*Copyright 2024 Matthew Kanter*
*Released under the MIT license*
[](https://github.com/mkantrr/automythonactions/workflows/build.yml)
## [`https://pypi.org/project/automython`](https://pypi.org/project/automython)
The **Automython** interpreter is a simple programming language that interprets its source code to Python as its target code to help understand and visualize automata theory.
This project originially started out as my senior Capstone project at UMW I would complete to graduate with University Honors. It originally started out as a proposal to create a whole new programming language, writing a compiler that translates my designed syntax into machine code to run a finite automata (either a deterministic finite automata (DFA) or non-deterministic (NFA), or if time permitted since it was only a one semester project a Turing machine) and output to the user a graph visualization of the inputted 5-tuple automata, whether an optional input word was accepted or rejected by the automata, and a table of transition functions/steps.
It slowly evolved as I worked closely with my fantastic professor, [**Dr. Andrew Marshall**](https://www.marshallandrew.net/) into creating an interpreter to Python to make use of pre-existing visualization libraries ([automata-lib](https://github.com/caleb531/automata), [visual-automata](https://github.com/lewiuberg/visual-automata)) and the small scope of the operations this language would have to perform. After all, what's the point of creating a whole new programming language that only performs one basic function when you could instead create a programming language that translates to a more widely used and broader use case programming language to make use of already written higher level logic? Point proven, nobody wants to write assembly. *shudders*
Thank you to [**Leonardo Giordani**](https://www.thedigitalcatonline.com/pages/about.html) for his TDD work on a simple calculator interpreter in Python that was heavily adapted for this package.
This package requires Python 3.8 or newer.
## Prerequisites
```sh
pip install 'automata-lib[visual]'
pip install pandas
pip install ipython
pip install forbiddenfruit
```
## Installing
You can install the latest version of Automython via `pip`:
```sh
pip install automython
```
## Usage
Automython can be used in two ways, similar to Python. It can be used as a command line interface or by passing in it's own readable `.theory` file type to read.
### CLI
Automython can be used similarly to how `python` can be on the command line. Simply run to bring up the interface:
```sh
automython
```
### File Syntax
To use this package once installed, you need to have a file with the extension `.theory` to run it on.
This `.theory` file has very simiilar syntax definitions to Python, however with some limitations as the scope is not quite that large.
All types in the `.theory` file operate the same as Python. The "native" types (supported types that are converted to Python) for Automython are:
- [`Integer`](#Integer)
- [`String`](#String)
- [`Boolean`](#Boolean)
- [`Dictionary`](#Dictionary)
- [`Set`](#Set)
Computational theory objects that are supported are:
- [`DFA`](#DFA) (i.e. `DFA(states, input_symbols, transitions, initial_state, final_states, allow_partial[optional]: bool`)
- [`NFA`](#NFA) (i.e. `NFA(states, input_symbols, transitions, initial_state, final_states)`)
The parameters within these calls can be substituted for any native types supported.
[Variables](#Variable) exist. Variables are defined such that `x = {'s1', 's2'}` assigns that set to the `x` variable.
Function calls exist too. Function calls return a value, usually only a string. You can assign a variable to these function_calls.
The available functions to use are:
- [`save()`](<#`save(path[optional], input_string[optional], horizontal[optional])`>)
- [`definition()`](#`definition()`)
- [`test()`](#`test(input_string)`)
- [`open()`](#`open(path[optional])`)
- [`print()`](#`print(args[optional])`)
Each function can be wrapped in `print()` to display the value returned from each function.
### Types
#### Integer
Integers in Automython act the same as `int`s in Python.
#### String
Strings in Automython act the same as `string`s in Python. You can use both `'` or `"` symbols to enclose them, just like Python.
#### Boolean
Booleans in Automython act the same as `bool`s in Python.
#### Dictionary
Dictioniaries in Automython act the same as `dict`s in Python. The only difference in the more limited support types for what you can assign to keys to only Automython's "native" types, and no other Python types that are not included.
#### Set
Sets in Automython act the same as `set`s in Python. The only difference in the more limited support types for what you can assign to keys to only Automython's "native" types, and no other Python types that are not included.
#### Tuple
Tuples in Automython act the same as `tuple`s in Python. The only difference is the more limited support, as you cannot perform most of the Python tuple functions and slick scripting you can here. They are built for a specific purpose, and it is moreso to be integrated with the computational theory concepts below.
#### DFA
**Deterministic Finite Automaton**:
The DFA object in Automython must resemble this syntax:
```python
DFA(states, input_symbols, transitions, initial_state, final_states, allow_partial[optional]: bool)
```
It must **also** be assigned to a variable; it cannot be treated as an expression, i.e.:
```python
dfa = DFA(states, input_symbols, transitions, initial_state, final_states, allow_partial[optional]: bool)
```
- The `states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.
- The `input_symbols` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.
- The `transitions` argument is a Dictionary. This can be either a Dictionary in the argument, or a variable that stores a Dictionary. The values of each key maps to an input symbol as a key to a String denoting the state.
- The `initial_state` argument is a String. This can be either a String in the argument, or a variable that stores a String.
- The `final_states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.
- The `allow_partial` argument is optional, and is a Boolean. The default value is `False` if it is not specified, but if it is specified, it allows the DFA to be validated as a partial DFA.
#### NFA
**Non-deterministic Finite Automaton**:
The NFA object in Automython must resemble this syntax:
```python
NFA(states, input_symbols, transitions, initial_state, final_states)
```
It must **also** be assigned to a variable; it cannot be treated as an expression, i.e.:
```python
nfa = NFA(states, input_symbols, transitions, initial_state, final_states)
```
- The `states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.
- The `input_symbols` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.
- The `transitions` argument is a Dictionary. This can be either a Dictionary in the argument, or a variable that stores a Dictionary. The values of each key maps to an input symbol as a key to a Set of states.
- The `initial_state` argument is a String. This can be either a String in the argument, or a variable that stores a String.
- The `final_states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.
#### DTM
**Deterministic Turing Machine**:
The DFA object in Automython must resemble this syntax:
```python
DTM(states, input_symbols, tape_symbols, transitions, initial_state, blank_symbol, final_states)
```
It must **also** be assigned to a variable; it cannot be treated as an expression, i.e.:
```python
dtm = DTM(states, input_symbols, tape_symbols, transitions, initial_state, blank_symbol, final_states)
```
- The `states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.
- The `input_symbols` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set. These symbols are all Strings, and are the only symbols that can exist on the tape before the Turing machine begins its run.
- The `tape_symbols` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set. These symbols are all Strings that are able to be read and written on the tape.
- The `transitions` argument is a Dictionary. This can be either a Dictionary in the argument, or a variable that stores a Dictionary. The values of each key maps to an input symbol as a key to a Tuple of strings denoting the new state, write symbol, and direction to move on the tape.
- The `initial_state` argument is a String. This can be either a String in the argument, or a variable that stores a String.
- The `blank_symbol` argument is a String. This can be either a String in the argument, or a variable that stores a String. This is the symbol on the tape that fills theoretical space on the tape where the input is not.
- The `final_states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.
### Functions
#### `save(path[optional], input_string[optional], horizontal[optional])`
The `save()` function can only be used when calling it on an automata variable already assigned, i.e. `fa.save()`.
When executed, this function will, by default, save the automata object's graph to a file named after the variable name, i.e. `fa.png`.
- If the `path` parameter is specified, which is a string, the function will save the automata object's graph to that path/file name.
- If the `input_string` parameter is specified, which is a string containing the input symbols from the automata's object, the function will save the automata object's graph with a gradient of transitions taken through the input_string as a test string. The transitions gradient in the saved file will be green if the string is accepted, or red if the string is rejected. This is, in essence, the visual representation of [`test()`](#`test(input_string)`)
- If the `horizontal` parameter is specified, which is a boolean, the function will save the automata object's graph in horizontal dimensions if `True` or vertical dimensions if `False`.
#### `definition()`
The `definition()` function can only be used when calling it on an automata variable already assigned, i.e. `fa.definition()`.
When executed, this function will return a string representation of the transition table-like structure of the automata object. You can use something like `print(fa.definition())` to print it to standard out.
- The → symbol denotes the initial state.
- The * symbol denotes an accepting state.
#### `test(input_string)`
The `test()` function can only be used when calling it on an automata variable already assigned, i.e. `fa.test("1010")`.
When executed, this function will return a string representation of the transition steps took through the automata. It returns this as a table-like structure, and also returns whether or not the input string is accepted or rejected by the automata. This is, in essense, the textual representation of [`definition()`](#`definition()`)
- The `input_string` argument must be a string.
- The → symbol denotes the initial state.
- The * symbol denotes an accepting state.
#### `open(path[optional])`
When executed, this function will, by default, open a file called `M.png` in the same directory as when `automython` command that was run.
- If the function is executed in the same way as `save()`, i.e. `fa.open()`, the default file it will open will be the variable it is called on (`fa.png`).
- If the `path` parameter is specified, which is a string, the function will open the specified file in the OS native viewer. If the path is specified **and** the function is called on a variable, the variable it is called on is obsolete, and the path parameter takes precedence.
#### `print(args[optional])`
The `print()` function is intended to be used as a standalone function, similar to how it is used in Python. If the function is called on a variable, the variable is obsolete. If the function is assigned to a variable, the variable will store `None`.
- If the `args` parameter is passed, this can be a variable, function call, expression, or "native" type, the string representation of whatever is passed in is printed straight through Python's `print()` function.
- If `args` is not passed, it will run the equivalent of `print('')` in Python.
Raw data
{
"_id": null,
"home_page": "https://github.com/mkantrr/automython",
"name": "automython",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": "Matthew Kanter <matt@matutu.dev>",
"keywords": "automata, finite, compiler, interpreter, theory, computational theory, non-deterministic, turing, machine, state",
"author": "Matthew Kanter",
"author_email": "Matthew Kanter <matt@matutu.dev>",
"download_url": "https://files.pythonhosted.org/packages/2b/0f/48a9d1fe739c799927e80e9794ac05797cfe6aa2b5a2d9b287b8774f49fb/automython-1.2.0.tar.gz",
"platform": null,
"description": "# Automython (v1.2.0)\n\n*Copyright 2024 Matthew Kanter* \n*Released under the MIT license*\n\n[](https://github.com/mkantrr/automythonactions/workflows/build.yml)\n\n## [`https://pypi.org/project/automython`](https://pypi.org/project/automython)\n\nThe **Automython** interpreter is a simple programming language that interprets its source code to Python as its target code to help understand and visualize automata theory.\n\nThis project originially started out as my senior Capstone project at UMW I would complete to graduate with University Honors. It originally started out as a proposal to create a whole new programming language, writing a compiler that translates my designed syntax into machine code to run a finite automata (either a deterministic finite automata (DFA) or non-deterministic (NFA), or if time permitted since it was only a one semester project a Turing machine) and output to the user a graph visualization of the inputted 5-tuple automata, whether an optional input word was accepted or rejected by the automata, and a table of transition functions/steps.\n\nIt slowly evolved as I worked closely with my fantastic professor, [**Dr. Andrew Marshall**](https://www.marshallandrew.net/) into creating an interpreter to Python to make use of pre-existing visualization libraries ([automata-lib](https://github.com/caleb531/automata), [visual-automata](https://github.com/lewiuberg/visual-automata)) and the small scope of the operations this language would have to perform. After all, what's the point of creating a whole new programming language that only performs one basic function when you could instead create a programming language that translates to a more widely used and broader use case programming language to make use of already written higher level logic? Point proven, nobody wants to write assembly. *shudders*\n\nThank you to [**Leonardo Giordani**](https://www.thedigitalcatonline.com/pages/about.html) for his TDD work on a simple calculator interpreter in Python that was heavily adapted for this package.\n\nThis package requires Python 3.8 or newer.\n\n## Prerequisites\n\n```sh\npip install 'automata-lib[visual]'\npip install pandas\npip install ipython\npip install forbiddenfruit\n```\n\n## Installing\n\nYou can install the latest version of Automython via `pip`:\n\n```sh\npip install automython\n```\n\n## Usage\n\nAutomython can be used in two ways, similar to Python. It can be used as a command line interface or by passing in it's own readable `.theory` file type to read.\n\n### CLI\nAutomython can be used similarly to how `python` can be on the command line. Simply run to bring up the interface:\n\n```sh\nautomython\n```\n\n### File Syntax\nTo use this package once installed, you need to have a file with the extension `.theory` to run it on.\nThis `.theory` file has very simiilar syntax definitions to Python, however with some limitations as the scope is not quite that large.\n\nAll types in the `.theory` file operate the same as Python. The \"native\" types (supported types that are converted to Python) for Automython are:\n\n- [`Integer`](#Integer)\n- [`String`](#String)\n- [`Boolean`](#Boolean)\n- [`Dictionary`](#Dictionary)\n- [`Set`](#Set)\n\nComputational theory objects that are supported are:\n\n- [`DFA`](#DFA) (i.e. `DFA(states, input_symbols, transitions, initial_state, final_states, allow_partial[optional]: bool`)\n- [`NFA`](#NFA) (i.e. `NFA(states, input_symbols, transitions, initial_state, final_states)`)\nThe parameters within these calls can be substituted for any native types supported.\n\n[Variables](#Variable) exist. Variables are defined such that `x = {'s1', 's2'}` assigns that set to the `x` variable.\n\nFunction calls exist too. Function calls return a value, usually only a string. You can assign a variable to these function_calls.\nThe available functions to use are:\n\n- [`save()`](<#`save(path[optional], input_string[optional], horizontal[optional])`>)\n- [`definition()`](#`definition()`)\n- [`test()`](#`test(input_string)`)\n- [`open()`](#`open(path[optional])`)\n- [`print()`](#`print(args[optional])`)\n\nEach function can be wrapped in `print()` to display the value returned from each function.\n\n### Types\n\n#### Integer\n\nIntegers in Automython act the same as `int`s in Python.\n\n#### String\n\nStrings in Automython act the same as `string`s in Python. You can use both `'` or `\"` symbols to enclose them, just like Python.\n\n#### Boolean\n\nBooleans in Automython act the same as `bool`s in Python.\n\n#### Dictionary\n\nDictioniaries in Automython act the same as `dict`s in Python. The only difference in the more limited support types for what you can assign to keys to only Automython's \"native\" types, and no other Python types that are not included.\n\n#### Set\n\nSets in Automython act the same as `set`s in Python. The only difference in the more limited support types for what you can assign to keys to only Automython's \"native\" types, and no other Python types that are not included.\n\n#### Tuple\n\nTuples in Automython act the same as `tuple`s in Python. The only difference is the more limited support, as you cannot perform most of the Python tuple functions and slick scripting you can here. They are built for a specific purpose, and it is moreso to be integrated with the computational theory concepts below.\n\n#### DFA\n**Deterministic Finite Automaton**:\n\nThe DFA object in Automython must resemble this syntax:\n```python\nDFA(states, input_symbols, transitions, initial_state, final_states, allow_partial[optional]: bool)\n```\nIt must **also** be assigned to a variable; it cannot be treated as an expression, i.e.:\n```python\ndfa = DFA(states, input_symbols, transitions, initial_state, final_states, allow_partial[optional]: bool)\n```\n\n- The `states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.\n- The `input_symbols` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.\n- The `transitions` argument is a Dictionary. This can be either a Dictionary in the argument, or a variable that stores a Dictionary. The values of each key maps to an input symbol as a key to a String denoting the state.\n- The `initial_state` argument is a String. This can be either a String in the argument, or a variable that stores a String.\n- The `final_states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.\n- The `allow_partial` argument is optional, and is a Boolean. The default value is `False` if it is not specified, but if it is specified, it allows the DFA to be validated as a partial DFA. \n\n#### NFA\n**Non-deterministic Finite Automaton**:\n\nThe NFA object in Automython must resemble this syntax:\n```python\nNFA(states, input_symbols, transitions, initial_state, final_states)\n```\nIt must **also** be assigned to a variable; it cannot be treated as an expression, i.e.:\n```python\nnfa = NFA(states, input_symbols, transitions, initial_state, final_states)\n```\n\n- The `states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.\n- The `input_symbols` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.\n- The `transitions` argument is a Dictionary. This can be either a Dictionary in the argument, or a variable that stores a Dictionary. The values of each key maps to an input symbol as a key to a Set of states.\n- The `initial_state` argument is a String. This can be either a String in the argument, or a variable that stores a String.\n- The `final_states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.\n\n#### DTM\n**Deterministic Turing Machine**:\n\nThe DFA object in Automython must resemble this syntax:\n```python\nDTM(states, input_symbols, tape_symbols, transitions, initial_state, blank_symbol, final_states)\n```\nIt must **also** be assigned to a variable; it cannot be treated as an expression, i.e.:\n```python\ndtm = DTM(states, input_symbols, tape_symbols, transitions, initial_state, blank_symbol, final_states)\n```\n\n- The `states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.\n- The `input_symbols` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set. These symbols are all Strings, and are the only symbols that can exist on the tape before the Turing machine begins its run.\n- The `tape_symbols` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set. These symbols are all Strings that are able to be read and written on the tape.\n- The `transitions` argument is a Dictionary. This can be either a Dictionary in the argument, or a variable that stores a Dictionary. The values of each key maps to an input symbol as a key to a Tuple of strings denoting the new state, write symbol, and direction to move on the tape.\n- The `initial_state` argument is a String. This can be either a String in the argument, or a variable that stores a String.\n- The `blank_symbol` argument is a String. This can be either a String in the argument, or a variable that stores a String. This is the symbol on the tape that fills theoretical space on the tape where the input is not.\n- The `final_states` argument is a Set. This can be either a Set in the argument, or a variable that stores a Set.\n\n### Functions\n\n#### `save(path[optional], input_string[optional], horizontal[optional])`\n\nThe `save()` function can only be used when calling it on an automata variable already assigned, i.e. `fa.save()`.\n\nWhen executed, this function will, by default, save the automata object's graph to a file named after the variable name, i.e. `fa.png`.\n\n- If the `path` parameter is specified, which is a string, the function will save the automata object's graph to that path/file name.\n- If the `input_string` parameter is specified, which is a string containing the input symbols from the automata's object, the function will save the automata object's graph with a gradient of transitions taken through the input_string as a test string. The transitions gradient in the saved file will be green if the string is accepted, or red if the string is rejected. This is, in essence, the visual representation of [`test()`](#`test(input_string)`) \n- If the `horizontal` parameter is specified, which is a boolean, the function will save the automata object's graph in horizontal dimensions if `True` or vertical dimensions if `False`.\n\n#### `definition()`\n\nThe `definition()` function can only be used when calling it on an automata variable already assigned, i.e. `fa.definition()`.\n\nWhen executed, this function will return a string representation of the transition table-like structure of the automata object. You can use something like `print(fa.definition())` to print it to standard out.\n\n- The \u2192 symbol denotes the initial state.\n- The * symbol denotes an accepting state.\n\n#### `test(input_string)`\n\nThe `test()` function can only be used when calling it on an automata variable already assigned, i.e. `fa.test(\"1010\")`.\n\nWhen executed, this function will return a string representation of the transition steps took through the automata. It returns this as a table-like structure, and also returns whether or not the input string is accepted or rejected by the automata. This is, in essense, the textual representation of [`definition()`](#`definition()`)\n\n- The `input_string` argument must be a string.\n- The \u2192 symbol denotes the initial state.\n- The * symbol denotes an accepting state.\n\n#### `open(path[optional])`\n\nWhen executed, this function will, by default, open a file called `M.png` in the same directory as when `automython` command that was run.\n\n- If the function is executed in the same way as `save()`, i.e. `fa.open()`, the default file it will open will be the variable it is called on (`fa.png`).\n- If the `path` parameter is specified, which is a string, the function will open the specified file in the OS native viewer. If the path is specified **and** the function is called on a variable, the variable it is called on is obsolete, and the path parameter takes precedence.\n\n#### `print(args[optional])`\n\nThe `print()` function is intended to be used as a standalone function, similar to how it is used in Python. If the function is called on a variable, the variable is obsolete. If the function is assigned to a variable, the variable will store `None`.\n\n- If the `args` parameter is passed, this can be a variable, function call, expression, or \"native\" type, the string representation of whatever is passed in is printed straight through Python's `print()` function.\n- If `args` is not passed, it will run the equivalent of `print('')` in Python.\n",
"bugtrack_url": null,
"license": "The MIT License (MIT) Copyright (c) 2024 Matthew Kanter Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",
"summary": "A simplistic programming language interpreter to Python to help students grasp finite automata theory programmatically and with a computed graph through visualization libraries.",
"version": "1.2.0",
"project_urls": {
"Homepage": "https://github.com/mkantrr/automython"
},
"split_keywords": [
"automata",
" finite",
" compiler",
" interpreter",
" theory",
" computational theory",
" non-deterministic",
" turing",
" machine",
" state"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "9e5b920e41d5f4ad37e338990701b2579ddd0886aaa8076521a9e0361e61512c",
"md5": "b0d9f8efdb02bfaf8c4d5903d996f66b",
"sha256": "214ddac09539a01c54b313311755464b7c4d245ff5b339083052b39baebcc6dc"
},
"downloads": -1,
"filename": "automython-1.2.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "b0d9f8efdb02bfaf8c4d5903d996f66b",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 25771,
"upload_time": "2024-04-03T19:20:13",
"upload_time_iso_8601": "2024-04-03T19:20:13.022196Z",
"url": "https://files.pythonhosted.org/packages/9e/5b/920e41d5f4ad37e338990701b2579ddd0886aaa8076521a9e0361e61512c/automython-1.2.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "2b0f48a9d1fe739c799927e80e9794ac05797cfe6aa2b5a2d9b287b8774f49fb",
"md5": "47fa91c32c0c868a4873e66458e525f5",
"sha256": "c072a01dd6d658565e0331291266c4fa93827483d35181ebd083ce405b10c8d1"
},
"downloads": -1,
"filename": "automython-1.2.0.tar.gz",
"has_sig": false,
"md5_digest": "47fa91c32c0c868a4873e66458e525f5",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 23384,
"upload_time": "2024-04-03T19:20:19",
"upload_time_iso_8601": "2024-04-03T19:20:19.418485Z",
"url": "https://files.pythonhosted.org/packages/2b/0f/48a9d1fe739c799927e80e9794ac05797cfe6aa2b5a2d9b287b8774f49fb/automython-1.2.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-04-03 19:20:19",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "mkantrr",
"github_project": "automython",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [],
"lcname": "automython"
}
