moldo 0.1.0__tar.gz

moldo-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mutiibwa Grace Peter
+
+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. 

moldo-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: moldo
+Version: 0.1.0
+Summary: A visual programming language that compiles to Python
+Home-page: https://github.com/mutiibwa/moldo
+Author: Mutiibwa Grace Peter
+Author-email: mutiibwa.grace@example.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: antlr4-python3-runtime>=4.13.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Moldo - Visual Programming Language
+
+Moldo is a visual programming language that compiles to Python. It provides a block-based interface for creating programs while maintaining the power and flexibility of Python.
+
+## Features
+
+- Visual block-based programming interface
+- Compiles to Python code
+- Supports basic programming constructs (variables, input, loops)
+- Can import and use Python functions through decorators
+- Real-time code execution
+- File saving and loading
+
+## Installation
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/moldo.git
+cd moldo
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Generate ANTLR files:
+```bash
+antlr4 -Dlanguage=Python3 moldo/compiler/grammar.py
+```
+
+## Usage
+
+### Starting the API Server
+
+```bash
+uvicorn moldo.api.server:app --reload
+```
+
+### Using the Visual Editor
+
+1. Open the visual editor in your browser
+2. Drag and drop blocks to create your program
+3. Click "Run" to execute the code
+4. Use "Save" to save your program as a Moldo file
+
+### Python Integration
+
+To make Python functions available in Moldo, use the `@moldo_function` decorator:
+
+```python
+from moldo.decorators import moldo_function
+
+@moldo_function(reference_name="add_numbers")
+def add(a: int, b: int) -> int:
+    return a + b
+```
+
+## Project Structure
+
+- `moldo/compiler/` - Contains the Moldo language compiler
+  - `grammar.py` - ANTLR grammar definition
+  - `parser.py` - Parser implementation
+  - `generator.py` - Python code generator
+- `moldo/editor/` - Visual editor implementation
+- `moldo/api/` - REST API server
+- `moldo/decorators.py` - Python integration decorators
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details. 

moldo-0.1.0/README.md

@@ -0,0 +1,75 @@
+# Moldo - Visual Programming Language
+
+Moldo is a visual programming language that compiles to Python. It provides a block-based interface for creating programs while maintaining the power and flexibility of Python.
+
+## Features
+
+- Visual block-based programming interface
+- Compiles to Python code
+- Supports basic programming constructs (variables, input, loops)
+- Can import and use Python functions through decorators
+- Real-time code execution
+- File saving and loading
+
+## Installation
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/moldo.git
+cd moldo
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Generate ANTLR files:
+```bash
+antlr4 -Dlanguage=Python3 moldo/compiler/grammar.py
+```
+
+## Usage
+
+### Starting the API Server
+
+```bash
+uvicorn moldo.api.server:app --reload
+```
+
+### Using the Visual Editor
+
+1. Open the visual editor in your browser
+2. Drag and drop blocks to create your program
+3. Click "Run" to execute the code
+4. Use "Save" to save your program as a Moldo file
+
+### Python Integration
+
+To make Python functions available in Moldo, use the `@moldo_function` decorator:
+
+```python
+from moldo.decorators import moldo_function
+
+@moldo_function(reference_name="add_numbers")
+def add(a: int, b: int) -> int:
+    return a + b
+```
+
+## Project Structure
+
+- `moldo/compiler/` - Contains the Moldo language compiler
+  - `grammar.py` - ANTLR grammar definition
+  - `parser.py` - Parser implementation
+  - `generator.py` - Python code generator
+- `moldo/editor/` - Visual editor implementation
+- `moldo/api/` - REST API server
+- `moldo/decorators.py` - Python integration decorators
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details. 

moldo-0.1.0/moldo/api/server.py

@@ -0,0 +1,99 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Optional, Dict, Any, List
+from ..compiler.parser import MoldoParser
+from ..decorators import MoldoFunction
+
+app = FastAPI(title="Moldo API")
+parser = MoldoParser()
+
+class MoldoCode(BaseModel):
+    code: str
+    python_modules: Optional[Dict[str, str]] = None
+
+class ExecutionResult(BaseModel):
+    output: str
+    error: Optional[str] = None
+
+@app.post("/compile")
+async def compile_code(moldo_code: MoldoCode) -> Dict[str, str]:
+    """
+    Compile Moldo code to Python.
+    
+    Args:
+        moldo_code: The Moldo code to compile
+        
+    Returns:
+        Dictionary containing the generated Python code
+    """
+    try:
+        # Import any Python modules if provided
+        if moldo_code.python_modules:
+            for name, path in moldo_code.python_modules.items():
+                parser.import_python_module(path)
+        
+        # Compile the Moldo code
+        python_code = parser.parse(moldo_code.code)
+        return {"python_code": python_code}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.post("/execute")
+async def execute_code(moldo_code: MoldoCode) -> ExecutionResult:
+    """
+    Execute Moldo code and return the result.
+    
+    Args:
+        moldo_code: The Moldo code to execute
+        
+    Returns:
+        Execution result containing output and any errors
+    """
+    try:
+        # Import any Python modules if provided
+        if moldo_code.python_modules:
+            for name, path in moldo_code.python_modules.items():
+                parser.import_python_module(path)
+        
+        # Compile and execute the code
+        python_code = parser.parse(moldo_code.code)
+        
+        # Create a new namespace for execution
+        namespace = {}
+        
+        # Execute the code
+        exec(python_code, namespace)
+        
+        # Capture any output
+        output = namespace.get('__output__', '')
+        return ExecutionResult(output=output)
+    except Exception as e:
+        return ExecutionResult(output="", error=str(e))
+
+@app.get("/functions")
+async def get_available_functions() -> Dict[str, List[str]]:
+    """
+    Get a list of all available Moldo functions.
+    
+    Returns:
+        Dictionary containing the list of available functions
+    """
+    return {"functions": parser.get_available_functions()}
+
+@app.post("/functions/{name}")
+async def execute_function(name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Execute a specific Moldo function.
+    
+    Args:
+        name: The name of the function to execute
+        args: The arguments to pass to the function
+        
+    Returns:
+        Dictionary containing the function result
+    """
+    try:
+        result = parser.execute_function(name, **args)
+        return {"result": result}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

moldo-0.1.0/moldo/cli.py

@@ -0,0 +1,59 @@
+import argparse
+import sys
+from pathlib import Path
+from .compiler.parser import MoldoParser
+from .api.server import app
+import uvicorn
+
+def compile_file(args):
+    """Compile a Moldo file to Python."""
+    parser = MoldoParser()
+    with open(args.input, 'r') as f:
+        code = f.read()
+    
+    try:
+        python_code = parser.parse(code)
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(python_code)
+        else:
+            print(python_code)
+    except Exception as e:
+        print(f"Error compiling file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def run_server(args):
+    """Start the Moldo API server."""
+    uvicorn.run(
+        "moldo.api.server:app",
+        host=args.host,
+        port=args.port,
+        reload=args.reload
+    )
+
+def main():
+    parser = argparse.ArgumentParser(description="Moldo - Visual Programming Language")
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+
+    # Compile command
+    compile_parser = subparsers.add_parser("compile", help="Compile Moldo code to Python")
+    compile_parser.add_argument("input", help="Input Moldo file")
+    compile_parser.add_argument("-o", "--output", help="Output Python file")
+    compile_parser.set_defaults(func=compile_file)
+
+    # Server command
+    server_parser = subparsers.add_parser("serve", help="Start the Moldo API server")
+    server_parser.add_argument("--host", default="127.0.0.1", help="Host to bind to")
+    server_parser.add_argument("--port", type=int, default=8000, help="Port to bind to")
+    server_parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+    server_parser.set_defaults(func=run_server)
+
+    args = parser.parse_args()
+    if args.command:
+        args.func(args)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

moldo-0.1.0/moldo/compiler/MoldoLexer.py

@@ -0,0 +1,89 @@
+# Generated from moldo/compiler/Moldo.g4 by ANTLR 4.9.2
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\f")
+        buf.write("h\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\3\2\3\2\3\2\3\2\3\2")
+        buf.write("\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3")
+        buf.write("\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6")
+        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\7\7A\n\7\f\7\16\7")
+        buf.write("D\13\7\3\b\6\bG\n\b\r\b\16\bH\3\t\7\tL\n\t\f\t\16\tO\13")
+        buf.write("\t\3\n\6\nR\n\n\r\n\16\nS\3\n\3\n\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\7\13^\n\13\f\13\16\13a\13\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\4M_\2\f\3\3\5\4\7\5\t\6\13\7\r\b\17\t")
+        buf.write("\21\n\23\13\25\f\3\2\6\5\2C\\aac|\6\2\62;C\\aac|\4\2>")
+        buf.write(">@@\5\2\13\f\17\17\"\"\2l\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
+        buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2")
+        buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\3\27\3\2\2")
+        buf.write("\2\5\37\3\2\2\2\7!\3\2\2\2\t+\3\2\2\2\13\64\3\2\2\2\r")
+        buf.write(">\3\2\2\2\17F\3\2\2\2\21M\3\2\2\2\23Q\3\2\2\2\25W\3\2")
+        buf.write("\2\2\27\30\7>\2\2\30\31\7o\2\2\31\32\7d\2\2\32\33\7n\2")
+        buf.write("\2\33\34\7q\2\2\34\35\7e\2\2\35\36\7m\2\2\36\4\3\2\2\2")
+        buf.write("\37 \7@\2\2 \6\3\2\2\2!\"\7>\2\2\"#\7\61\2\2#$\7o\2\2")
+        buf.write("$%\7d\2\2%&\7n\2\2&\'\7q\2\2\'(\7e\2\2()\7m\2\2)*\7@\2")
+        buf.write("\2*\b\3\2\2\2+,\7>\2\2,-\7r\2\2-.\7{\2\2./\7v\2\2/\60")
+        buf.write("\7j\2\2\60\61\7q\2\2\61\62\7p\2\2\62\63\7@\2\2\63\n\3")
+        buf.write("\2\2\2\64\65\7>\2\2\65\66\7\61\2\2\66\67\7r\2\2\678\7")
+        buf.write("{\2\289\7v\2\29:\7j\2\2:;\7q\2\2;<\7p\2\2<=\7@\2\2=\f")
+        buf.write("\3\2\2\2>B\t\2\2\2?A\t\3\2\2@?\3\2\2\2AD\3\2\2\2B@\3\2")
+        buf.write("\2\2BC\3\2\2\2C\16\3\2\2\2DB\3\2\2\2EG\n\4\2\2FE\3\2\2")
+        buf.write("\2GH\3\2\2\2HF\3\2\2\2HI\3\2\2\2I\20\3\2\2\2JL\13\2\2")
+        buf.write("\2KJ\3\2\2\2LO\3\2\2\2MN\3\2\2\2MK\3\2\2\2N\22\3\2\2\2")
+        buf.write("OM\3\2\2\2PR\t\5\2\2QP\3\2\2\2RS\3\2\2\2SQ\3\2\2\2ST\3")
+        buf.write("\2\2\2TU\3\2\2\2UV\b\n\2\2V\24\3\2\2\2WX\7>\2\2XY\7#\2")
+        buf.write("\2YZ\7/\2\2Z[\7/\2\2[_\3\2\2\2\\^\13\2\2\2]\\\3\2\2\2")
+        buf.write("^a\3\2\2\2_`\3\2\2\2_]\3\2\2\2`b\3\2\2\2a_\3\2\2\2bc\7")
+        buf.write("/\2\2cd\7/\2\2de\7@\2\2ef\3\2\2\2fg\b\13\2\2g\26\3\2\2")
+        buf.write("\2\b\2BHMS_\3\b\2\2")
+        return buf.getvalue()
+
+
+class MoldoLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    T__0 = 1
+    T__1 = 2
+    T__2 = 3
+    T__3 = 4
+    T__4 = 5
+    IDENTIFIER = 6
+    TEXT = 7
+    PYTHON_CODE = 8
+    WS = 9
+    COMMENT = 10
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'<mblock'", "'>'", "'</mblock>'", "'<python>'", "'</python>'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "IDENTIFIER", "TEXT", "PYTHON_CODE", "WS", "COMMENT" ]
+
+    ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "IDENTIFIER", 
+                  "TEXT", "PYTHON_CODE", "WS", "COMMENT" ]
+
+    grammarFileName = "Moldo.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.9.2")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+

moldo-0.1.0/moldo/compiler/MoldoListener.py

@@ -0,0 +1,66 @@
+# Generated from moldo/compiler/Moldo.g4 by ANTLR 4.9.2
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .MoldoParser import MoldoParser
+else:
+    from MoldoParser import MoldoParser
+
+# This class defines a complete listener for a parse tree produced by MoldoParser.
+class MoldoListener(ParseTreeListener):
+
+    # Enter a parse tree produced by MoldoParser#program.
+    def enterProgram(self, ctx:MoldoParser.ProgramContext):
+        pass
+
+    # Exit a parse tree produced by MoldoParser#program.
+    def exitProgram(self, ctx:MoldoParser.ProgramContext):
+        pass
+
+
+    # Enter a parse tree produced by MoldoParser#block.
+    def enterBlock(self, ctx:MoldoParser.BlockContext):
+        pass
+
+    # Exit a parse tree produced by MoldoParser#block.
+    def exitBlock(self, ctx:MoldoParser.BlockContext):
+        pass
+
+
+    # Enter a parse tree produced by MoldoParser#mblock.
+    def enterMblock(self, ctx:MoldoParser.MblockContext):
+        pass
+
+    # Exit a parse tree produced by MoldoParser#mblock.
+    def exitMblock(self, ctx:MoldoParser.MblockContext):
+        pass
+
+
+    # Enter a parse tree produced by MoldoParser#block_type.
+    def enterBlock_type(self, ctx:MoldoParser.Block_typeContext):
+        pass
+
+    # Exit a parse tree produced by MoldoParser#block_type.
+    def exitBlock_type(self, ctx:MoldoParser.Block_typeContext):
+        pass
+
+
+    # Enter a parse tree produced by MoldoParser#block_content.
+    def enterBlock_content(self, ctx:MoldoParser.Block_contentContext):
+        pass
+
+    # Exit a parse tree produced by MoldoParser#block_content.
+    def exitBlock_content(self, ctx:MoldoParser.Block_contentContext):
+        pass
+
+
+    # Enter a parse tree produced by MoldoParser#python_block.
+    def enterPython_block(self, ctx:MoldoParser.Python_blockContext):
+        pass
+
+    # Exit a parse tree produced by MoldoParser#python_block.
+    def exitPython_block(self, ctx:MoldoParser.Python_blockContext):
+        pass
+
+
+
+del MoldoParser