sagnos 0.1.0__tar.gz

sagnos-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: sagnos
+Version: 0.1.0
+Summary: The Spring Boot of Python for Flutter
+Author: Siddhardh
+Keywords: flutter,dart,backend,framework
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110.0
+Requires-Dist: uvicorn[standard]>=0.29.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: typer>=0.12.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: watchfiles>=0.21.0
+Requires-Dist: psutil>=5.9.0

sagnos-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sagnos"
+version = "0.1.0"
+description = "The Spring Boot of Python for Flutter"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Siddhardh" }]
+keywords = ["flutter", "dart", "backend", "framework"]
+
+dependencies = [
+    "fastapi>=0.110.0",
+    "uvicorn[standard]>=0.29.0",
+    "pydantic>=2.0.0",
+    "jinja2>=3.1.0",
+    "requests>=2.31.0",
+    "websockets>=12.0",
+    "typer>=0.12.0",
+    "rich>=13.0.0",
+    "watchfiles>=0.21.0",
+    "psutil>=5.9.0",
+]
+
+[project.scripts]
+sagnos = "sagnos.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["sagnos*"]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]

sagnos-0.1.0/sagnos/__init__.py

@@ -0,0 +1,15 @@
+from .core import (
+    expose, model, stream,
+    SagnosError, NotFoundError,
+    ValidationError_, AuthError, ForbiddenError,
+)
+from .server import SagnosApp, SagnosAuth
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "expose", "model", "stream",
+    "SagnosApp", "SagnosAuth",
+    "SagnosError", "NotFoundError",
+    "ValidationError_", "AuthError", "ForbiddenError",
+]

sagnos-0.1.0/sagnos/codegen.py

@@ -0,0 +1,354 @@
+"""
+sagnos/codegen.py
+Reads the schema and generates Dart files.
+This is what runs when you do: sagnos generate
+"""
+
+from pathlib import Path
+from jinja2 import Environment, BaseLoader
+import requests
+
+
+# ─── Dart Templates ───────────────────────────────────────────────────────────
+
+MODELS_TEMPLATE = """// AUTO-GENERATED BY SAGNOS — DO NOT EDIT
+// Run `sagnos generate` to regenerate
+// Schema hash: {{ schema_hash }}
+
+{% for model in models %}
+class {{ model.name }} {
+  {% for f in model.fields %}
+  final {{ f.dart_type }} {{ f.dart_name }};
+  {% endfor %}
+
+  const {{ model.name }}({
+    {% for f in model.fields %}
+    {% if f.optional %}this.{{ f.dart_name }},
+    {% else %}required this.{{ f.dart_name }},
+    {% endif %}
+    {% endfor %}
+  });
+
+  factory {{ model.name }}.fromJson(Map<String, dynamic> json) {
+    return {{ model.name }}(
+      {% for f in model.fields %}
+      {{ f.dart_name }}: {{ f.from_json }},
+      {% endfor %}
+    );
+  }
+
+Map<String, dynamic> toJson() {
+    return {
+      {% for f in model.fields %}
+      '{{ f.name }}': {{ f.dart_name }},
+      {% endfor %}
+    };
+  }
+
+  {{ model.name }} copyWith({
+    {% for f in model.fields %}
+    {% if f.optional %}
+    {{ f.dart_type }} {{ f.dart_name }},
+    {% else %}
+    {{ f.dart_type }}? {{ f.dart_name }},
+    {% endif %}
+    {% endfor %}
+  }) {
+    return {{ model.name }}(
+      {% for f in model.fields %}
+      {{ f.dart_name }}: {{ f.dart_name }} ?? this.{{ f.dart_name }},
+      {% endfor %}
+    );
+  }
+
+  @override
+  String toString() {
+    return '{{ model.name }}({% for f in model.fields %}{{ f.dart_name }}: ${{ f.dart_name }}{% if not loop.last %}, {% endif %}{% endfor %})';
+  }
+}
+{% endfor %}
+"""
+
+CLIENT_TEMPLATE = """// AUTO-GENERATED BY SAGNOS — DO NOT EDIT
+// Run `sagnos generate` to regenerate
+// Schema hash: {{ schema_hash }}
+
+import 'dart:convert';
+import 'package:http/http.dart' as http;
+import 'models.dart';
+import 'sagnos_exception.dart';
+
+class SagnosClient {
+  final String baseUrl;
+  String? _token;
+
+  SagnosClient({
+    this.baseUrl = '{{ base_url }}',
+    String? token,
+  }) : _token = token;
+
+  void setToken(String token) => _token = token;
+  void clearToken() => _token = null;
+
+  Map<String, String> get _headers => {
+    'Content-Type': 'application/json',
+    if (_token != null) 'Authorization': 'Bearer $_token',
+  };
+
+  // [FIX-3] Call this in main() to detect schema drift
+  Future<void> checkSchemaDrift() async {
+    try {
+      final uri      = Uri.parse('$baseUrl/sagnos/schema-version');
+      final response = await http.get(uri, headers: _headers);
+      if (response.statusCode != 200) return;
+      final data       = json.decode(response.body);
+      const clientHash = '{{ schema_hash }}';
+      final serverHash = data['schema_hash'] as String?;
+      if (serverHash != null && serverHash != clientHash) {
+        print('[Sagnos] Schema drift detected! Run sagnos generate.');
+      }
+    } catch (_) {}
+  }
+
+  Future<dynamic> _get(String path, [Map<String, String>? query]) async {
+    final uri      = Uri.parse('$baseUrl$path').replace(queryParameters: query);
+    final response = await http.get(uri, headers: _headers);
+    return _handle(response);
+  }
+
+  Future<dynamic> _post(String path, Map<String, dynamic> body) async {
+    final uri      = Uri.parse('$baseUrl$path');
+    final response = await http.post(
+      uri,
+      headers: _headers,
+      body: json.encode(body),
+    );
+    return _handle(response);
+  }
+
+  dynamic _handle(http.Response response) {
+    final decoded = json.decode(response.body) as Map<String, dynamic>;
+    if (response.statusCode >= 200 && response.statusCode < 300) {
+      return decoded['data'];
+    }
+    throw SagnosException(
+      statusCode: response.statusCode,
+      errorCode:  decoded['error_code'] ?? 'UNKNOWN',
+      message:    decoded['message']    ?? 'Unknown error',
+      detail:     decoded['detail'],
+    );
+  }
+
+  // ── Generated Methods ─────────────────────────────────────────────────────
+
+  {% for ep in endpoints %}
+  {% if ep.deprecated %}@Deprecated('Deprecated on the backend.'){% endif %}
+  /// {{ ep.docstring or ep.dart_method }}
+  Future<{{ ep.return_dart }}> {{ ep.dart_method }}({% for p in ep.params %}{{ p.dart_type }} {{ p.name }}{% if not loop.last %}, {% endif %}{% endfor %}) async {
+    {% if ep.method == 'GET' %}
+    final data = await _get('{{ ep.path }}'{% if ep.params %}, { {% for p in ep.params %}'{{ p.name }}': {{ p.name }}.toString(){% if not loop.last %}, {% endif %}{% endfor %} }{% endif %});
+    {% else %}
+    final data = await _post('{{ ep.path }}', { {% for p in ep.params %}'{{ p.name }}': {{ p.name }}{% if not loop.last %}, {% endif %}{% endfor %} });
+    {% endif %}
+    {% set rt = ep.return_dart %}
+    {% if rt == 'void' or rt == 'dynamic' %}
+    return data;
+    {% elif rt == 'String' or rt == 'String?' %}
+    return data as {{ rt }};
+    {% elif rt == 'int' or rt == 'int?' %}
+    return data as int;
+    {% elif rt == 'double' or rt == 'double?' %}
+    return (data as num).toDouble();
+    {% elif rt == 'bool' or rt == 'bool?' %}
+    return data as bool;
+    {% elif rt == 'DateTime' or rt == 'DateTime?' %}
+    return {% if ep.return_optional %}data == null ? null : {% endif %}DateTime.parse(data as String);
+    {% elif rt.startswith('List<') %}
+    {% set inner = rt[5:-1] %}
+    {% if inner in ['int', 'double', 'String', 'bool'] %}
+    return (data as List).cast<{{ inner }}>();
+    {% else %}
+    return (data as List).map((e) => {{ inner }}.fromJson(e as Map<String, dynamic>)).toList();
+    {% endif %}
+    {% elif rt.endswith('?') %}
+    return data == null ? null : {{ rt[:-1] }}.fromJson(data as Map<String, dynamic>);
+    {% else %}
+    return {{ rt }}.fromJson(data as Map<String, dynamic>);
+    {% endif %}
+  }
+
+  {% endfor %}
+}
+"""
+
+EXCEPTION_TEMPLATE = """// AUTO-GENERATED BY SAGNOS — DO NOT EDIT
+
+class SagnosException implements Exception {
+  final int statusCode;
+  final String errorCode;
+  final String message;
+  final dynamic detail;
+
+  const SagnosException({
+    required this.statusCode,
+    required this.errorCode,
+    required this.message,
+    this.detail,
+  });
+
+  bool get isNotFound     => errorCode == 'NOT_FOUND';
+  bool get isUnauthorized => errorCode == 'UNAUTHORIZED';
+  bool get isForbidden    => errorCode == 'FORBIDDEN';
+  bool get isValidation   => errorCode == 'VALIDATION_ERROR';
+  bool get isInternal     => errorCode == 'INTERNAL_ERROR';
+
+  @override
+  String toString() => 'SagnosException[$errorCode $statusCode]: $message';
+}
+"""
+
+STREAM_TEMPLATE = """// AUTO-GENERATED BY SAGNOS — DO NOT EDIT
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+import 'models.dart';
+import 'sagnos_exception.dart';
+
+class SagnosStream<T> {
+  final String url;
+  final T Function(Map<String, dynamic>) fromJson;
+  final String? token;
+
+  WebSocket? _socket;
+  StreamController<T>? _controller;
+  bool _disposed = false;
+
+  SagnosStream({
+    required this.url,
+    required this.fromJson,
+    this.token,
+  });
+
+  Stream<T> get stream {
+    _controller ??= StreamController<T>.broadcast(
+      onListen: _connect,
+      onCancel: _disconnect,
+    );
+    return _controller!.stream;
+  }
+
+  Future<void> _connect() async {
+    try {
+      _socket = await WebSocket.connect(url);
+      _socket!.listen(
+        (raw) {
+          if (_disposed) return;
+          try {
+            final decoded = json.decode(raw as String) as Map<String, dynamic>;
+            if (decoded['status'] == 'error') {
+              _controller?.addError(SagnosException(
+                statusCode: decoded['status_code'] ?? 500,
+                errorCode:  decoded['error_code']  ?? 'WS_ERROR',
+                message:    decoded['message']     ?? 'Stream error',
+              ));
+            } else {
+              _controller?.add(fromJson(decoded['data']));
+            }
+          } catch (e) {
+            _controller?.addError(e);
+          }
+        },
+        onError: (e) => _controller?.addError(e),
+        onDone: () { if (!_disposed) _reconnect(); },
+      );
+    } catch (e) {
+      _controller?.addError(e);
+      await Future.delayed(const Duration(seconds: 2));
+      if (!_disposed) await _connect();
+    }
+  }
+
+  Future<void> _reconnect() async {
+    await Future.delayed(const Duration(seconds: 1));
+    if (!_disposed) await _connect();
+  }
+
+  void _disconnect() => _socket?.close();
+
+  void dispose() {
+    _disposed = true;
+    _socket?.close();
+    _controller?.close();
+  }
+}
+"""
+
+
+# ─── Generator ────────────────────────────────────────────────────────────────
+
+def generate(schema_url: str, output_dir: str, base_url: str = None):
+    """
+    Pull schema from running Sagnos server.
+    Generate all Dart files into output_dir.
+    """
+    print(f"Fetching schema from {schema_url} ...")
+
+    try:
+        resp = requests.get(schema_url, timeout=5)
+        resp.raise_for_status()
+        schema = resp.json()
+    except requests.ConnectionError:
+        print("Could not connect. Is the Sagnos server running?")
+        return
+    except Exception as e:
+        print(f"Error: {e}")
+        return
+
+    if base_url is None:
+        base_url = schema_url.replace("/sagnos/schema", "")
+
+    _write_files(schema, output_dir, base_url)
+
+
+def generate_from_schema(schema: dict, output_dir: str, base_url: str = "http://127.0.0.1:8000"):
+    """Generate Dart files directly from a schema dict — no server needed."""
+    _write_files(schema, output_dir, base_url)
+
+
+def _write_files(schema: dict, output_dir: str, base_url: str):
+    env  = Environment(loader=BaseLoader(), trim_blocks=True, lstrip_blocks=True)
+    out  = Path(output_dir)
+    hash = schema.get("schema_hash", "unknown")
+
+    out.mkdir(parents=True, exist_ok=True)
+
+    ctx = {
+        "models":      schema["models"],
+        "endpoints":   schema["endpoints"],
+        "streams":     schema.get("streams", []),
+        "base_url":    base_url,
+        "schema_hash": hash,
+    }
+
+    files = {
+        "models.dart":           MODELS_TEMPLATE,
+        "sagnos_client.dart":    CLIENT_TEMPLATE,
+        "sagnos_exception.dart": EXCEPTION_TEMPLATE,
+        "sagnos_stream.dart":    STREAM_TEMPLATE,
+    }
+
+    for filename, tmpl_str in files.items():
+        content = env.from_string(tmpl_str).render(**ctx)
+        (out / filename).write_text(content, encoding="utf-8")
+        print(f"  Generated: {filename}")
+
+    # Write lock file
+    (out / "sagnos.lock").write_text(
+        f"schema_hash={hash}\n"
+        f"sagnos_version={schema['version']}\n",
+        encoding="utf-8"
+    )
+
+    print(f"\nDone. {len(files)} files written to {output_dir}")
+    print(f"Schema hash: {hash}")

sagnos-0.1.0/sagnos/config.py

@@ -0,0 +1,40 @@
+"""
+sagnos/config.py
+Project config — reads/writes sagnos.json
+"""
+
+import json
+from pathlib import Path
+from dataclasses import dataclass, asdict
+
+
+CONFIG_FILE = "sagnos.json"
+
+
+@dataclass
+class SagnosConfig:
+    name:         str  = "my_app"
+    version:      str  = "0.1.0"
+    port:         int  = 8000
+    host:         str  = "127.0.0.1"
+    backend_entry: str = "backend/main.py"
+    ui_dir:       str  = "ui"
+    dart_output:  str  = "ui/lib/sagnos"
+
+    @classmethod
+    def load(cls, root: Path = None) -> "SagnosConfig":
+        root        = root or Path.cwd()
+        config_path = root / CONFIG_FILE
+        if not config_path.exists():
+            raise FileNotFoundError(
+                f"No sagnos.json found in {root}.\n"
+                "Run `sagnos new <name>` to create a project."
+            )
+        with open(config_path) as f:
+            data = json.load(f)
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+    def save(self, root: Path = None):
+        root = root or Path.cwd()
+        with open(root / CONFIG_FILE, "w") as f:
+            json.dump(asdict(self), f, indent=2)