tinybird 0.0.1.dev12__tar.gz → 0.0.1.dev14__tar.gz

{tinybird-0.0.1.dev12 → tinybird-0.0.1.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tinybird
-Version: 0.0.1.dev12
+Version: 0.0.1.dev14
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird

{tinybird-0.0.1.dev12 → tinybird-0.0.1.dev14}/tinybird/tb/cli.py

@@ -14,6 +14,7 @@ import tinybird.tb.modules.create
 import tinybird.tb.modules.datasource
 import tinybird.tb.modules.fmt
 import tinybird.tb.modules.job
+import tinybird.tb.modules.login
 import tinybird.tb.modules.mock
 import tinybird.tb.modules.pipe
 import tinybird.tb.modules.tag

{tinybird-0.0.1.dev12 → tinybird-0.0.1.dev14}/tinybird/tb/modules/cli.py

@@ -565,24 +565,17 @@ async def push(
 @click.option(
     "--folder", default=None, type=click.Path(exists=True, file_okay=False), help="Folder where files will be placed"
 )
-@click.option(
-    "--auto/--no-auto",
-    is_flag=True,
-    default=True,
-    help="Saves datafiles automatically into their default directories (/datasources or /pipes). Default is True",
-)
-@click.option("--match", default=None, help="Retrieve any resourcing matching the pattern. eg --match _test")
 @click.option("-f", "--force", is_flag=True, default=False, help="Override existing files")
 @click.option("--fmt", is_flag=True, default=False, help="Format files before saving")
 @click.pass_context
 @coro
-async def pull(ctx: Context, folder: str, auto: bool, match: Optional[str], force: bool, fmt: bool) -> None:
+async def pull(ctx: Context, folder: str, force: bool, fmt: bool) -> None:
     """Retrieve latest versions for project files from Tinybird."""
 
     client = ctx.ensure_object(dict)["client"]
     folder = folder if folder else getcwd()
 
-    return await folder_pull(client, folder, auto, match, force, fmt=fmt)
+    return await folder_pull(client, folder, force, fmt=fmt)
 
 
 @cli.command()

{tinybird-0.0.1.dev12 → tinybird-0.0.1.dev14}/tinybird/tb/modules/datafile/diff.py

@@ -121,12 +121,12 @@ async def diff_command(
     if filenames:
         if len(filenames) == 1:
             filenames = [filenames[0], *get_project_filenames(filenames[0])]
-        await folder_pull(client, target_dir, False, None, True, verbose=False)
+        await folder_pull(client, target_dir, True, verbose=False)
     else:
         filenames = get_project_filenames(".")
         if verbose:
             click.echo("Saving remote resources in .diff_tmp folder.\n")
-        await folder_pull(client, target_dir, False, None, True, verbose=verbose, progress_bar=progress_bar)
+        await folder_pull(client, target_dir, True, verbose=verbose, progress_bar=progress_bar)
 
     remote_datasources: List[Dict[str, Any]] = await client.datasources()
     remote_pipes: List[Dict[str, Any]] = await client.pipes()

{tinybird-0.0.1.dev12 → tinybird-0.0.1.dev14}/tinybird/tb/modules/datafile/pull.py

@@ -1,7 +1,7 @@
 import re
 from asyncio import Semaphore, gather
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import aiofiles
 import click
@@ -16,38 +16,39 @@ from tinybird.tb.modules.datafile.format_pipe import format_pipe
 async def folder_pull(
     client: TinyB,
     folder: str,
-    auto: bool,
-    match: Optional[str],
     force: bool,
     verbose: bool = True,
     progress_bar: bool = False,
     fmt: bool = False,
 ):
-    pattern = re.compile(match) if match else None
-
-    def _get_latest_versions(resources: List[str]):
+    def _get_latest_versions(resources: List[Tuple[str, str]]):
         versions: Dict[str, Any] = {}
 
-        for x in resources:
+        for x, resource_type in resources:
             t = get_name_version(x)
             t["original_name"] = x
             if t["version"] is None:
                 t["version"] = -1
             name = t["name"]
+            t["type"] = resource_type
 
             if name not in versions or name == x or versions[name]["version"] < t["version"]:
                 versions[name] = t
         return versions
 
-    def get_file_folder(extension: str):
-        if not auto:
-            return None
+    def get_file_folder(extension: str, resource_type: Optional[str]):
         if extension == "datasource":
             return "datasources"
+        if resource_type == "endpoint":
+            return "endpoints"
+        if resource_type == "sink":
+            return "sinks"
+        if resource_type == "copy":
+            return "copies"
+        if resource_type == "materialized":
+            return "materializations"
         if extension == "pipe":
             return "pipes"
-        if extension == "token":
-            return "tokens"
         return None
 
     async def write_files(
@@ -61,11 +62,6 @@ async def folder_pull(
         async def write_resource(k: Dict[str, Any]):
             name = f"{k['name']}.{extension}"
             try:
-                if pattern and not pattern.search(name):
-                    if verbose:
-                        click.echo(FeedbackManager.info_skipping_resource(resource=name))
-                    return
-
                 resource = await getattr(client, get_resource_function)(k["original_name"])
                 resource_to_write = resource
 
@@ -76,11 +72,11 @@ async def folder_pull(
                         resource_to_write = await format_pipe(name, content=resource)
 
                 dest_folder = folder
-                if "." in k["name"] and extension != "token":
+                if "." in k["name"]:
                     dest_folder = Path(folder) / "vendor" / k["name"].split(".", 1)[0]
                     name = f"{k['name'].split('.', 1)[1]}.{extension}"
 
-                file_folder = get_file_folder(extension)
+                file_folder = get_file_folder(extension, k["type"])
                 f = Path(dest_folder) / file_folder if file_folder is not None else Path(dest_folder)
 
                 if not f.exists():
@@ -125,11 +121,11 @@ async def folder_pull(
 
     try:
         datasources = await client.datasources()
-        remote_datasources = sorted([x["name"] for x in datasources])
+        remote_datasources = sorted([(x["name"], x.get("type", "csv")) for x in datasources], key=lambda x: x[0])
         datasources_versions = _get_latest_versions(remote_datasources)
 
         pipes = await client.pipes()
-        remote_pipes = sorted([x["name"] for x in pipes])
+        remote_pipes = sorted([(pipe["name"], pipe.get("type", "default")) for pipe in pipes], key=lambda x: x[0])
         pipes_versions = _get_latest_versions(remote_pipes)
 
         resources = list(datasources_versions.keys()) + list(pipes_versions.keys())

tinybird-0.0.1.dev14/tinybird/tb/modules/login.py

@@ -0,0 +1,169 @@
+import http.server
+import socketserver
+import threading
+import time
+import urllib.parse
+import webbrowser
+from urllib.parse import urlencode
+
+import click
+import requests
+
+from tinybird.feedback_manager import FeedbackManager
+from tinybird.tb.modules.cli import CLIConfig, cli
+
+
+class AuthHandler(http.server.SimpleHTTPRequestHandler):
+    def do_GET(self):
+        # The access_token is in the URL fragment, which is not sent to the server
+        # We'll send a small HTML page that extracts the token and sends it back to the server
+        self.send_response(200)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        self.wfile.write(b"""
+        <html>
+        <head>
+            <style>
+                body {
+                    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+                    background: #f5f5f5;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    height: 100vh;
+                    margin: 0;
+                }
+                .message {
+                    background: white;
+                    padding: 2rem 3rem;
+                    border-radius: 8px;
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                    text-align: center;
+                    display: flex;
+                    flex-direction: column;
+                    align-items: center;
+                }
+                h1 {
+                    color: #25283D;
+                    font-size: 1.2rem;
+                    margin: 0;
+                    font-weight: 500;
+                }
+            </style>
+        </head>
+        <body>
+            <div class="message">
+                <h1>Authenticating...</h1>
+            </div>
+            <script>
+                var hash = window.location.hash.substr(1);
+                var access_token = new URLSearchParams(hash).get('access_token');
+                window.history.pushState({}, '', '/');
+                fetch('/?token=' + access_token, {method: 'POST'})
+                    .then(() => {
+                        document.querySelector('.message h1').textContent = 'Authentication successful! You can close this window.';
+                    });
+            </script>
+        </body>
+        </html>
+        """)
+
+    def do_POST(self):
+        parsed_path = urllib.parse.urlparse(self.path)
+        query_params = urllib.parse.parse_qs(parsed_path.query)
+
+        if "token" in query_params:
+            token = query_params["token"][0]
+            self.server.auth_callback(token)
+            self.send_response(200)
+            self.end_headers()
+        else:
+            self.send_error(400, "Missing 'token' parameter")
+
+        self.server.shutdown()
+
+    def log_message(self, format, *args):
+        # Suppress log messages
+        return
+
+
+AUTH_SERVER_PORT = 49160
+
+
+class AuthServer(socketserver.TCPServer):
+    allow_reuse_address = True
+
+    def __init__(self, server_address, RequestHandlerClass, auth_callback):
+        self.auth_callback = auth_callback
+        super().__init__(server_address, RequestHandlerClass)
+
+
+def start_server(auth_callback):
+    with AuthServer(("", AUTH_SERVER_PORT), AuthHandler, auth_callback) as httpd:
+        httpd.timeout = 30
+        start_time = time.time()
+        while time.time() - start_time < 60:  # Run for a maximum of 60 seconds
+            httpd.handle_request()
+
+
+@cli.command()
+@click.option(
+    "--host",
+    help="Set custom host if it's different than https://api.tinybird.co. Check https://www.tinybird.co/docs/api-reference/overview#regions-and-endpoints for the available list of regions",
+)
+@click.option(
+    "--workspace",
+    help="Set the workspace to authenticate to. If not set, the default workspace will be used.",
+)
+def login(host: str, workspace: str):
+    """Authenticate via browser."""
+    auth_event = threading.Event()
+    auth_code = [None]  # Using a list to store the code, as it's mutable
+    config = CLIConfig.get_project_config()
+    host = host or "https://api.tinybird.co"
+
+    def auth_callback(code):
+        auth_code[0] = code
+        auth_event.set()
+
+    click.echo("Opening browser for authentication...")
+
+    # Start the local server in a separate thread
+    server_thread = threading.Thread(target=start_server, args=(auth_callback,))
+    server_thread.daemon = True
+    server_thread.start()
+
+    # Open the browser to the auth page
+    client_id = "T6excMo8IKguvUw4vFNYfqlt9pe6msCU"
+    callback_url = f"http://localhost:{AUTH_SERVER_PORT}"
+    params = {
+        "client_id": client_id,
+        "redirect_uri": callback_url,
+        "response_type": "token",
+        "scope": "openid profile email",
+    }
+    auth_url = f"https://auth.tinybird.co/authorize?{urlencode(params)}"
+    webbrowser.open(auth_url)
+
+    # Wait for the authentication to complete or timeout
+    if auth_event.wait(timeout=60):  # Wait for up to 60 seconds
+        params = {}
+        if workspace:
+            params["workspace_id"] = workspace
+        response = requests.get(
+            f"https://api.tinybird.co/v0/user/tokens?{urlencode(params)}",
+            headers={"Authorization": f"Bearer {auth_code[0]}"},
+        )
+        data = response.json()
+        cli_config = CLIConfig.get_project_config()
+        workspace_token = data["workspace_token"]
+        user_token = data["user_token"]
+        cli_config.set_token(workspace_token)
+        cli_config.set_token_for_host(workspace_token, host)
+        cli_config.set_user_token(user_token)
+        config.set_host(host)
+
+        cli_config.persist_to_file()
+        click.echo(FeedbackManager.success(message="✓ Authentication successful!"))
+    else:
+        click.echo(FeedbackManager.error(message="Authentication failed or timed out."))

{tinybird-0.0.1.dev12 → tinybird-0.0.1.dev14}/tinybird.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tinybird
-Version: 0.0.1.dev12
+Version: 0.0.1.dev14
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird

{tinybird-0.0.1.dev12 → tinybird-0.0.1.dev14}/tinybird.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ tinybird/tb/modules/fmt.py
 tinybird/tb/modules/job.py
 tinybird/tb/modules/llm.py
 tinybird/tb/modules/local.py
+tinybird/tb/modules/login.py
 tinybird/tb/modules/mock.py
 tinybird/tb/modules/pipe.py
 tinybird/tb/modules/prompts.py