apkpy 0.1.0__py3-none-any.whl

apkpy-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: apkpy
+Version: 0.1.0
+Summary: A simple framework to build Android apps using Python and CSS-like styling
+Home-page: https://github.com/teu-usuario/apkpy
+Author: Teu Nome
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: click
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# APKPy 🚀
+
+A lightweight Python framework to build Android apps with a simple syntax and CSS-like styling. 
+
+APKPy allows you to create mobile interfaces using Python functions and style them with a CSS-inspired syntax, providing a real-time preview on Windows before compiling to Android.
+
+## Installation
+
+```bash
+pip install apkpy
+Quick Start
+Create a file named writehere.py:
+
+Python
+from apkpy_lib.ui import button, input_field, run
+
+# Define your styles
+style = """
+main_button {
+    background-color: blue;
+    color: white;
+}
+"""
+
+# Build your UI
+input_field(placeholder="Enter your name")
+button("Click Me", id="main_button")
+
+# Run the Windows preview
+run()
+How to Run
+To see your app preview on Windows, simply run:
+
+Bash
+python writehere.py
+To build your Android project (APK structure):
+
+Bash
+apkpy build
+Features
+Python-based UI: No need to learn complex XML.
+
+CSS Styling: Easy styling with a familiar syntax.
+
+Instant Preview: See how your app looks on Windows immediately.
+
+Android Ready: Transpiles your Python code into native Java code.

apkpy-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+apkpy_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apkpy_lib/cli.py,sha256=d-RgUZ9r10TA3yV18ofpeosLwiVkxTI23fnvGRJdQ0k,2543
+apkpy_lib/ui.py,sha256=Qle_6GPrNvUPDW0EfCEB1rDTMFhVlqXqcSq9RbLFxVc,2443
+apkpy_lib/core/compiler.py,sha256=X2WwhiRt0wbcSP0A42xAqicPNKNxFZlTJTpFMBhHFyw,2707
+apkpy_lib/core/style_parser.py,sha256=ElQJcP0LDBqAqLcPQM43RugAXVNgJze7KPeYpKWL-LY,480
+apkpy_lib/core/__pycache__/compiler.cpython-313.pyc,sha256=A6MHfx0lCcn4ALWsxWC0haXS3h5XMXT6GdeuLMmRNhE,1929
+apkpy_lib/templates/android_project/app/src/main/AndroidManifest.xml,sha256=0_fVGYg_9_VMcbnwDS46-l_7Cqxnp5v-HBvsjrXg7aA,663
+apkpy_lib/templates/android_project/app/src/main/java/com/exemplo/MainActivity.java,sha256=QQ1u3BQpYKYjpIn4chG5cHSH9nbGSXey3JTmTL98HIM,663
+apkpy-0.1.0.dist-info/METADATA,sha256=7ndFK9Vp0uxOZJ7EYA_pFs9PT8h9kV3_Cmofrm7IOMQ,1737
+apkpy-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+apkpy-0.1.0.dist-info/entry_points.txt,sha256=UgHrx1XVZPGs7VZeiafagRDTL1Z5z175mt9WjMf_7uo,45
+apkpy-0.1.0.dist-info/top_level.txt,sha256=Z4vuhNYR6Ybxm2qoF-387wz_wqmtPS-uJ2a78p33Ae0,10
+apkpy-0.1.0.dist-info/RECORD,,

apkpy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

apkpy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+apkpy = apkpy_lib.cli:main

apkpy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+apkpy_lib

apkpy_lib/cli.py

@@ -0,0 +1,74 @@
+import click
+import os
+import zipfile
+import shutil
+
+# Adicione esta linha aqui para o editor saber de onde vem a função!
+from .core.compiler import translate_python_to_java
+
+@click.group()
+def main():
+    """APKPy: Transforme Python em Projetos Android (APK)"""
+    pass
+
+# ... resto do código (start e build) ...
+
+@main.command()
+@click.argument('name')
+def start(name):
+    """Cria um novo projeto: apkpy start meu_projeto"""
+    click.echo(f"Criando o projeto: {name}...")
+    
+    # Define os caminhos
+    current_dir = os.getcwd()
+    project_path = os.path.join(current_dir, name)
+    
+    if not os.path.exists(project_path):
+        os.makedirs(project_path)
+        # Cria o arquivo de entrada do usuário
+        with open(os.path.join(project_path, "writehere.py"), "w") as f:
+            f.write("# Escreva seu app aqui\nbutton('Clique aqui')")
+        click.echo(f"Sucesso! Entre na pasta {name} e edite o writehere.py")
+    else:
+        click.echo("Erro: Essa pasta já existe.")
+
+@main.command()
+def build():
+    """Compila o código e gera o ZIP pronto para o Android Studio"""
+    file_path = "writehere.py"
+    template_path = os.path.join(os.path.dirname(__file__), "templates/android_project")
+    output_zip = "projeto_final.zip"
+    
+    if not os.path.exists(file_path):
+        click.echo("Erro: writehere.py não encontrado.")
+        return
+
+    # 1. Gerar o código Java
+    with open(file_path, "r", encoding="utf-8") as f:
+        python_code = f.read()
+    
+    java_code = translate_python_to_java(python_code)
+
+    # 2. Criar uma pasta temporária para montar o projeto
+    build_dir = "build_temp"
+    if os.path.exists(build_dir): shutil.rmtree(build_dir)
+    shutil.copytree(template_path, build_dir)
+
+    # 3. Injetar o código na MainActivity.java
+    main_activity_path = os.path.join(build_dir, "app/src/main/java/com/exemplo/MainActivity.java")
+    
+    with open(main_activity_path, "r") as f:
+        content = f.read()
+    
+    # Substitui o marcador pelo código gerado pelo seu compiler.py
+    new_content = content.replace("// INJECT_CODE_HERE", java_code)
+    
+    with open(main_activity_path, "w") as f:
+        f.write(new_content)
+
+    # 4. Transformar em ZIP
+    shutil.make_archive("meu_app_android", 'zip', build_dir)
+    shutil.rmtree(build_dir) # Limpa a pasta temporária
+
+    click.echo("🚀 Sucesso! Arquivo 'meu_app_android.zip' gerado.")
+    click.echo("Agora é só extrair e abrir no Android Studio.")

apkpy_lib/core/compiler.py

@@ -0,0 +1,68 @@
+import ast
+# No topo do compiler.py adicione:
+from .style_parser import parse_css
+
+class JavaTranspiler(ast.NodeVisitor):
+    def __init__(self, styles=None):
+        self.java_lines = []
+        self.counter = 0
+        self.styles = styles or {} # Aqui guardamos os estilos
+
+    def visit_Call(self, node):
+        if isinstance(node.func, ast.Name) and node.func.id == 'button':
+            self.counter += 1
+            
+            # Tenta pegar o ID do botão (ex: id="botão1")
+            button_id = None
+            for kw in node.keywords:
+                if kw.arg == 'id':
+                    button_id = kw.value.value
+
+            label = node.args[0].value
+            var_name = f"btn{self.counter}"
+            
+            java_code = f'\n        Button {var_name} = new Button(this);'
+            java_code += f'\n        {var_name}.setText("{label}");'
+
+            # APLICA O CSS NO JAVA
+            if button_id in self.styles:
+                s = self.styles[button_id]
+                if 'background-color' in s:
+                    color = s['background-color'].replace('blue', 'Color.BLUE').replace('red', 'Color.RED')
+                    java_code += f'\n        {var_name}.setBackgroundColor({color});'
+                if 'color' in s:
+                    java_code += f'\n        {var_name}.setTextColor(Color.WHITE);'
+
+            java_code += f'\n        layout.addView({var_name});'
+            self.java_lines.append(java_code)
+
+def translate_python_to_java(python_code):
+    try:
+        # 1. Extrair o estilo (CSS) se ele existir dentro de triplas aspas
+        # Procuramos por algo entre style = """ ... """
+        import re
+        style_match = re.search(r'style\s*=\s*"""(.*?)"""', python_code, re.DOTALL)
+        
+        styles = {}
+        clean_python_code = python_code
+        
+        if style_match:
+            css_content = style_match.group(1)
+            styles = parse_css(css_content) # Usa o teu style_parser!
+            # Removemos o bloco de estilo para o AST não se confundir
+            clean_python_code = python_code.replace(style_match.group(0), "")
+
+        # 2. Transforma o código Python limpo em árvore (AST)
+        tree = ast.parse(clean_python_code)
+        
+        # 3. Passamos os estilos encontrados para o Transpiler
+        transpiler = JavaTranspiler(styles=styles)
+        transpiler.visit(tree)
+        
+        if not transpiler.java_lines:
+            return "        // Nenhum componente detectado"
+            
+        return "\n".join(transpiler.java_lines)
+        
+    except Exception as e:
+        return f"        // Erro na tradução: {str(e)}"

apkpy_lib/core/style_parser.py

@@ -0,0 +1,15 @@
+import re
+
+def parse_css(css_text):
+    styles = {}
+    # Procura blocos tipo: nome { propriedades }
+    blocks = re.findall(r'(\w+)\s*{(.*?)}', css_text, re.DOTALL)
+    
+    for name, content in blocks:
+        props = {}
+        # Procura cada linha tipo: color: red;
+        lines = re.findall(r'([\w-]+)\s*:\s*(.*?);', content)
+        for key, value in lines:
+            props[key.strip()] = value.strip()
+        styles[name.strip()] = props
+    return styles

apkpy_lib/templates/android_project/app/src/main/AndroidManifest.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.microsoft.com/apk/res/android">
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="Meu App ApkPy"
+        android:theme="@style/Theme.AppCompat.Light">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

apkpy_lib/templates/android_project/app/src/main/java/com/exemplo/MainActivity.java

@@ -0,0 +1,22 @@
+package com.exemplo;
+
+import android.os.Bundle;
+import android.widget.LinearLayout;
+import android.widget.Button;
+import androidx.appcompat.app.AppCompatActivity;
+
+public class MainActivity extends AppCompatActivity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.setTheme(androidx.appcompat.R.style.Theme_AppCompat_Light);
+        super.onCreate(savedInstanceState);
+        
+        LinearLayout layout = new LinearLayout(this);
+        layout.setOrientation(LinearLayout.VERTICAL);
+
+        // O Python vai colocar os botões aqui:
+        // INJECT_CODE_HERE
+
+        setContentView(layout);
+    }
+}

apkpy_lib/ui.py

@@ -0,0 +1,78 @@
+import tkinter as tk
+import re
+import __main__
+
+# Dicionário global para guardar os estilos processados
+global_styles = {}
+
+def parse_css_internal(css_text):
+    """Lógica para transformar o texto CSS num dicionário Python"""
+    styles = {}
+    # Procura blocos: nome { ... }
+    blocks = re.findall(r'(\w+)\s*{(.*?)}', css_text, re.DOTALL)
+    for name, content in blocks:
+        props = {}
+        # Procura propriedades: color: red;
+        lines = re.findall(r'([\w-]+)\s*:\s*(.*?);', content)
+        for key, value in lines:
+            props[key.strip()] = value.strip()
+        styles[name.strip()] = props
+    return styles
+
+def load_styles_now():
+    """Procura a variável 'style' no ficheiro writehere.py e carrega-a"""
+    global global_styles
+    if hasattr(__main__, 'style'):
+        global_styles = parse_css_internal(__main__.style)
+
+class AppPreview:
+    def __init__(self):
+        self.root = tk.Tk()
+        self.root.title("APKPy Preview - Windows")
+        self.root.geometry("360x640")
+        
+        # Frame principal que simula o ecrã do telemóvel
+        self.layout = tk.Frame(self.root)
+        self.layout.pack(fill="both", expand=True, padx=20, pady=20)
+
+    def add_button(self, text, command=None, bg=None, fg=None):
+        # Se não houver cor definida no CSS, usa o padrão do sistema
+        tk_bg = bg if bg else "SystemButtonFace"
+        tk_fg = fg if fg else "black"
+        
+        btn = tk.Button(
+            self.layout, 
+            text=text, 
+            font=("Arial", 12), 
+            command=command, 
+            bg=tk_bg, 
+            fg=tk_fg,
+            relief="raised",
+            pady=5
+        )
+        btn.pack(pady=10, fill="x")
+
+    def run(self):
+        self.root.mainloop()
+
+# Instância única da interface
+_app = AppPreview()
+
+def button(text, id=None, command=None):
+    """Função chamada no writehere.py"""
+    # Força o carregamento do CSS se ele ainda não foi lido
+    if not global_styles:
+        load_styles_now()
+        
+    # Busca o estilo pelo ID (ex: botao_azul)
+    style = global_styles.get(id, {})
+    bg = style.get('background-color')
+    fg = style.get('color')
+    
+    _app.add_button(text, command, bg, fg)
+
+def run():
+    """Inicia a janela do Windows"""
+    # Garante uma última verificação dos estilos antes de abrir
+    load_styles_now()
+    _app.run()