devflow-tools 0.1.0__py3-none-any.whl

devflow/__init__.py

@@ -0,0 +1,4 @@
+from .ai import AI
+from .cli import CLI
+from .network import SocketServer, SocketClient
+from .help import display_help,help

devflow/ai.py

@@ -0,0 +1,108 @@
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeoutError
+from typing import Union, List, Optional
+from google import genai
+from google.genai import errors
+
+
+class AI:
+    def __init__(
+        self,
+        api_keys: Union[str, List[str], bool] = False,
+        model: str = "gemini-3.6-flash",
+    ):
+        """Initialise l'instance AI.
+
+        :param api_keys: Clé unique (str), liste de clés (list), ou False pour
+          utiliser os.environ['gemini_1']
+        :param model: Nom du modèle Gemini (par défaut: gemini-3.6-flash)
+        """
+        self.model = model
+        self.key_list: List[str] = []
+        self.current_key_index: int = 0
+
+        # Gestion des clés d'API
+        if api_keys is False or api_keys is None:
+            env_key = os.environ.get("gemini_1") or os.environ.get("GEMINI_API_KEY")
+            if not env_key:
+                raise ValueError(
+                    "Aucune clé trouvée. Définis la variable 'gemini_1' ou passe une clé."
+                )
+            self.key_list = [env_key]
+        elif isinstance(api_keys, str):
+            self.key_list = [api_keys]
+        elif isinstance(api_keys, list):
+            if not api_keys:
+                raise ValueError("La liste de clés API ne peut pas être vide.")
+            self.key_list = api_keys
+        else:
+            raise TypeError("Format de api_keys invalide.")
+
+        self._init_client()
+
+    def _init_client(self):
+        """Instancie le client Gemini avec la clé courante."""
+        current_key = self.key_list[self.current_key_index]
+        self.client = genai.Client(api_key=current_key)
+
+    def _rotate_key(self) -> bool:
+        """Passe à la clé suivante dans la liste si disponible."""
+        if len(self.key_list) <= 1:
+            return False
+        self.current_key_index = (self.current_key_index + 1) % len(self.key_list)
+        self._init_client()
+        return True
+
+    def request(self, prompt: str, timeout: Optional[float] = None) -> str:
+        """Envoie un prompt à Gemini et retourne la réponse complète.
+
+        :param prompt: Le texte à envoyer à l'IA
+        :param timeout: Temps max en secondes avant d'abandonner (Optionnel)
+        """
+        attempts = 0
+        max_attempts = len(self.key_list)
+
+        def _execute():
+            response = self.client.models.generate_content(
+                model=self.model, contents=prompt
+            )
+            return response.text
+
+        while attempts < max_attempts:
+            try:
+                if timeout is not None:
+                    # Vrai timeout exécuté dans un thread séparé
+                    with ThreadPoolExecutor(max_workers=1) as executor:
+                        future = executor.submit(_execute)
+                        return future.result(timeout=timeout)
+                else:
+                    return _execute()
+
+            except FutureTimeoutError:
+                raise TimeoutError(f"La requête a dépassé le timeout de {timeout}s")
+            except (errors.APIError, errors.ServerError) as e:
+                attempts += 1
+                if not self._rotate_key() or attempts >= max_attempts:
+                    raise e
+            except Exception as e:
+                raise e
+
+    def ask_stream(self, prompt: str):
+        """Génère du texte en streaming (compatible avec devflow.cli)."""
+        attempts = 0
+        max_attempts = len(self.key_list)
+
+        while attempts < max_attempts:
+            try:
+                response = self.client.models.generate_content_stream(
+                    model=self.model, contents=prompt
+                )
+                for chunk in response:
+                    if chunk.text:
+                        yield chunk.text
+                return
+            except errors.APIError as e:
+                attempts += 1
+                if not self._rotate_key() or attempts >= max_attempts:
+                    raise e

devflow/cli.py

@@ -0,0 +1,209 @@
+from contextlib import contextmanager
+import random
+import time
+from typing import List, Optional, Union
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Prompt
+from rich.text import Text
+
+# Console unique partagée
+console = Console()
+
+
+class CLI:
+    # -------------------------------------------------------------------------
+    # 1. RENDU DE TEXTE ET STREAMING
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def print_stream(generator) -> str:
+        """Affiche un flux de texte (generator) en Markdown et en temps réel."""
+        full_text = ""
+        with Live(
+            Markdown(full_text),
+            console=console,
+            refresh_per_second=12,
+            vertical_overflow="visible",
+        ) as live:
+            for chunk in generator:
+                if chunk:
+                    full_text += chunk
+                    live.update(Markdown(full_text))
+        return full_text
+
+    @staticmethod
+    def type_text(
+        text: str,
+        speed: float = 0.03,
+        color: str = "green",
+        cursor: bool = True,
+    ) -> None:
+        """Simule un effet de frappe à la machine à écrire avec curseur clignotant."""
+        displayed = ""
+        with Live(
+            console=console, refresh_per_second=20, transient=True
+        ) as live:
+            for letter in text:
+                displayed += letter
+                cur_str = (
+                    ("_" if int(time.time() * 4) % 2 == 0 else " ")
+                    if cursor
+                    else ""
+                )
+                live.update(f"[{color}]{displayed}{cur_str}[/{color}]")
+                time.sleep(speed)
+
+        # Affichage final fixé dans la console
+        console.print(f"[{color}]{text}[/{color}]")
+
+    @staticmethod
+    def live_sequence(
+        items: List[str], delay: float = 0.01, repeat: int = 1
+    ) -> str:
+        """Anime l'affichage d'une liste de fragments de texte progressivement."""
+        full_text = ""
+        with Live(
+            Markdown(""),
+            console=console,
+            refresh_per_second=30,
+            vertical_overflow="visible",
+        ) as live_display:
+            for cycle in range(repeat):
+                full_text = ""
+                for chunk in items:
+                    full_text += chunk
+                    live_display.update(Markdown(full_text))
+                    time.sleep(delay)
+                if cycle < repeat - 1:
+                    time.sleep(0.2)
+        return full_text
+
+    # -------------------------------------------------------------------------
+    # 2. INDICATEURS DE CHARGEMENT ET PROGRESSION
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    @contextmanager
+    def status(message: str = "Traitement en cours..."):
+        """Affiche un spinner animé pendant l'exécution d'un bloc de code."""
+        with console.status(
+            f"[bold cyan]{message}[/bold cyan]", spinner="dots"
+        ):
+            yield
+
+    @staticmethod
+    def animate_dots(
+        text: str = "Chargement",
+        max_dots: int = 20,
+        speed: float = 0.08,
+        color: str = "cyan",
+    ) -> None:
+        """Affiche un texte avec des points d'attente animés (ex: Chargement...)."""
+        with Live(
+            console=console, refresh_per_second=15, transient=True
+        ) as live:
+            for i in range(max_dots + 1):
+                live.update(f"[{color}]{text}{'.' * i}[/{color}]")
+                time.sleep(speed)
+        console.print(f"[bold green]✔ {text} terminé.[/bold green]")
+
+    @staticmethod
+    def animate_frames(
+        frames: List[str],
+        repetitions: int = 5,
+        speed: float = 0.25,
+        color: str = "cyan",
+    ) -> None:
+        """Boucle sur une liste de frames textuelles (ex: spinners personnalisés)."""
+        with Live(
+            console=console, refresh_per_second=15, transient=True
+        ) as live:
+            for _ in range(repetitions):
+                for frame in frames:
+                    live.update(Text(frame, style=color))
+                    time.sleep(speed)
+
+    @staticmethod
+    def progress_bar(
+        title: str = "Progression",
+        total: int = 100,
+        speed: float = 0.03,
+        color: str = "yellow",
+    ) -> None:
+        """Affiche une barre de progression simple et fluide."""
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task(f"[{color}]{title}", total=total)
+            while not progress.finished:
+                time.sleep(speed)
+                progress.update(task, advance=1)
+
+    # -------------------------------------------------------------------------
+    # 3. INTERFACES, PANNEAUX ET SÉPARATEURS
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def rule(
+        title: str = "", character: str = "─", color: str = "bright_blue"
+    ) -> None:
+        """Trace une ligne séparatrice horizontale avec un titre optionnel."""
+        width = console.width
+        if title:
+            text = f" {title} "
+            remaining = width - len(text)
+            left = remaining // 2
+            right = remaining - left
+            line = character * left + text + character * right
+        else:
+            line = character * width
+        console.print(line, style=color)
+
+    @staticmethod
+    def print_panel(
+        content: Union[str, Markdown],
+        title: str = "devflow",
+        style: str = "cyan",
+        expand: bool = True,
+    ) -> None:
+        """Affiche un contenu encadré dans un panneau stylisé."""
+        md = Markdown(content) if isinstance(content, str) else content
+        console.print(
+            Panel(
+                md, title=f"[bold]{title}[/bold]", border_style=style, expand=expand
+            )
+        )
+
+    @staticmethod
+    def ask(prompt_text: str = "Entrez votre message") -> str:
+        """Pose une question à l'utilisateur via une invite propre."""
+        return Prompt.ask(f"[bold green]?[/bold green] {prompt_text}")
+
+    # -------------------------------------------------------------------------
+    # 4. SIMULATION DE LOGS & UTILS
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def generate_logs(count: int = 10, speed: float = 0.01) -> None:
+        """Génère de faux logs système en défilement rapide pour des démos/tests."""
+        log_types = [
+            ("ERROR", "bold red"),
+            ("INFO", "bold white"),
+            ("WARNING", "bold yellow"),
+            ("SUCCESS", "bold green"),
+        ]
+        for i in range(1, count + 1):
+            level, color = random.choice(log_types)
+            pid = random.randint(1000, 9999)
+            code = random.randint(100000, 999999)
+            status = random.choice(["OK", "FAIL", "PENDING"])
+
+            msg = f"[{i:03d}] [{level}] Process_{pid} status={status} code={code}"
+            CLI.type_text(msg, speed=speed, color=color, cursor=False)

devflow/help.py

@@ -0,0 +1,170 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.syntax import Syntax
+
+console = Console()
+
+
+def display_help(module_name: str = None) -> None:
+    """Affiche l'aide interactive et la documentation de DevFlow."""
+    
+    # Titre principal
+    console.print()
+    console.print(
+        Panel(
+            "[bold cyan]🚀 DevFlow - Documentation & Aide[/bold cyan]\n"
+            "[dim]Bibliothèque modulaire : IA (Gemini), CLI (Rich), Sockets TCP.[/dim]",
+            border_style="bright_blue",
+            expand=False,
+        )
+    )
+
+    # -------------------------------------------------------------------------
+    # MODULE : AI
+    # -------------------------------------------------------------------------
+    if module_name in (None, "ai"):
+        console.print("\n[bold yellow]🤖 MODULE : devflow.AI[/bold yellow]")
+        table_ai = Table(show_header=True, header_style="bold magenta", expand=True)
+        table_ai.add_column("Méthode", style="cyan", width=22)
+        table_ai.add_column("Paramètres", style="green")
+        table_ai.add_column("Description", style="white")
+
+        table_ai.add_row(
+            "__init__()",
+            "model='gemini-2.5-flash', system_instruction=None",
+            "Initialise l'instance AI avec la clé API Google.",
+        )
+        table_ai.add_row(
+            "ask()",
+            "prompt: str",
+            "Envoie une requête et retourne la réponse complète sous forme de texte.",
+        )
+        table_ai.add_row(
+            "ask_stream()",
+            "prompt: str",
+            "Retourne un générateur pour lire la réponse morceau par morceau.",
+        )
+        console.print(table_ai)
+
+        example_ai = (
+            "from devflow import AI, CLI\n\n"
+            "ai = AI()\n"
+            "# Utilisation classique\n"
+            "reponse = ai.ask('Explique les sockets en 2 phrases')\n"
+            "print(reponse)\n\n"
+            "# Utilisation en streaming avec la CLI\n"
+            "CLI.print_stream(ai.ask_stream('Raconte une histoire courte'))"
+        )
+        console.print(Panel(Syntax(example_ai, "python", theme="monokai"), title="[bold]Exemple AI[/bold]", border_style="dim"))
+
+    # -------------------------------------------------------------------------
+    # MODULE : CLI
+    # -------------------------------------------------------------------------
+    if module_name in (None, "cli"):
+        console.print("\n[bold yellow]💻 MODULE : devflow.CLI[/bold yellow]")
+        table_cli = Table(show_header=True, header_style="bold magenta", expand=True)
+        table_cli.add_column("Méthode", style="cyan", width=22)
+        table_cli.add_column("Paramètres", style="green")
+        table_cli.add_column("Description", style="white")
+
+        table_cli.add_row(
+            "print_stream()",
+            "generator",
+            "Affiche un flux de texte (MarkDown) en temps réel.",
+        )
+        table_cli.add_row(
+            "type_text()",
+            "text, speed=0.03, color='green', cursor=True",
+            "Effet machine à écrire avec curseur clignotant.",
+        )
+        table_cli.add_row(
+            "animate_dots()",
+            "text='Chargement', max_dots=20, speed=0.08, color='cyan'",
+            "Animation de points d'attente dynamiques.",
+        )
+        table_cli.add_row(
+            "progress_bar()",
+            "title='Progression', total=100, speed=0.03, color='yellow'",
+            "Barre de progression fluide.",
+        )
+        table_cli.add_row(
+            "rule()",
+            "title='', character='─', color='bright_blue'",
+            "Ligne séparatrice avec ou sans titre.",
+        )
+        table_cli.add_row(
+            "print_panel()",
+            "content, title='devflow', style='cyan', expand=True",
+            "Encadre du texte dans un panneau stylisé.",
+        )
+        table_cli.add_row(
+            "ask()",
+            "prompt_text='Entrez votre message'",
+            "Invite de saisie utilisateur stylisée.",
+        )
+        console.print(table_cli)
+
+        example_cli = (
+            "from devflow import CLI\n\n"
+            "CLI.rule(title='DEBUT DE TÂCHE')\n"
+            "CLI.type_text('Connexion au serveur...', color='cyan')\n"
+            "CLI.progress_bar(title='Téléchargement', total=50)\n"
+            "CLI.print_panel('Operation réussie !', title='Succès', style='green')"
+        )
+        console.print(Panel(Syntax(example_cli, "python", theme="monokai"), title="[bold]Exemple CLI[/bold]", border_style="dim"))
+
+    # -------------------------------------------------------------------------
+    # MODULE : NETWORK
+    # -------------------------------------------------------------------------
+    if module_name in (None, "network"):
+        console.print("\n[bold yellow]🌐 MODULE : devflow.NETWORK[/bold yellow]")
+        table_net = Table(show_header=True, header_style="bold magenta", expand=True)
+        table_net.add_column("Classe / Méthode", style="cyan", width=22)
+        table_net.add_column("Paramètres", style="green")
+        table_net.add_column("Description", style="white")
+
+        table_net.add_row(
+            "SocketServer()",
+            "host='0.0.0.0', port=65432, buffer_size=4096",
+            "Serveur TCP multithreadé.",
+        )
+        table_net.add_row(
+            "SocketServer.start()",
+            "handler: Callable[[str], Union[str, Generator]]",
+            "Lance le serveur et exécute le handler à chaque message.",
+        )
+        table_net.add_row(
+            "SocketClient()",
+            "host='127.0.0.1', port=65432, buffer_size=4096",
+            "Client TCP simple.",
+        )
+        table_net.add_row(
+            "SocketClient.send()",
+            "message: str, timeout=10.0",
+            "Envoie un message et attend la réponse complète.",
+        )
+        table_net.add_row(
+            "SocketClient.send_stream()",
+            "message: str, timeout=10.0",
+            "Envoie un message et reçoit la réponse en flux (generator).",
+        )
+        console.print(table_net)
+
+        example_net = (
+            "# SERVEUR TCP\n"
+            "from devflow import SocketServer\n\n"
+            "server = SocketServer(port=65432)\n"
+            "server.start(handler=lambda msg: f'Reçu : {msg}')\n\n"
+            "# CLIENT TCP\n"
+            "from devflow import SocketClient\n\n"
+            "client = SocketClient(port=65432)\n"
+            "reponse = client.send('Hello Server !')\n"
+            "print(reponse)"
+        )
+        console.print(Panel(Syntax(example_net, "python", theme="monokai"), title="[bold]Exemple Network[/bold]", border_style="dim"))
+
+
+def help(module_name: str = None) -> None:
+    """Raccourci pour afficher l'aide."""
+    display_help(module_name)

devflow/network.py

@@ -0,0 +1,121 @@
+import socket
+import threading
+from typing import Callable, Optional, Generator, Union
+
+
+class SocketServer:
+    """Serveur TCP multithreadé simple et réutilisable."""
+
+    def __init__(self, host: str = "0.0.0.0", port: int = 65432, buffer_size: int = 4096):
+        self.host = host
+        self.port = port
+        self.buffer_size = buffer_size
+        self.server_socket: Optional[socket.socket] = None
+        self.is_running: bool = False
+
+    def _handle_client(
+        self,
+        conn: socket.socket,
+        addr: tuple,
+        handler: Callable[[str], Union[str, Generator[str, None, None]]],
+    ):
+        """Gère la communication avec un client connecté dans un thread dédié."""
+        try:
+            while self.is_running:
+                data = conn.recv(self.buffer_size)
+                if not data:
+                    break
+
+                message = data.decode("utf-8").strip()
+                if not message:
+                    continue
+
+                # Exécution de la fonction de traitement (callback)
+                result = handler(message)
+
+                # Si le handler est un générateur (ex: streaming Gemini)
+                if isinstance(result, Generator):
+                    for chunk in result:
+                        if chunk:
+                            conn.sendall(chunk.encode("utf-8"))
+                elif isinstance(result, str):
+                    conn.sendall(result.encode("utf-8"))
+
+        except (ConnectionResetError, BrokenPipeError):
+            pass
+        finally:
+            conn.close()
+
+    def start(self, handler: Callable[[str], Union[str, Generator[str, None, None]]]):
+        """Démarre le serveur et écoute les connexions entrantes (bloquant).
+
+        :param handler: Fonction recevant un message (str) et retournant une réponse (str ou générateur)
+        """
+        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.server_socket.bind((self.host, self.port))
+        self.server_socket.listen()
+        self.is_running = True
+
+        print(f"[devflow.network] Serveur actif sur {self.host}:{self.port}")
+
+        try:
+            while self.is_running:
+                conn, addr = self.server_socket.accept()
+                # Un thread par client connecté
+                client_thread = threading.Thread(
+                    target=self._handle_client,
+                    args=(conn, addr, handler),
+                    daemon=True,
+                )
+                client_thread.start()
+        except KeyboardInterrupt:
+            print("\n[devflow.network] Arrêt du serveur.")
+        finally:
+            self.stop()
+
+    def stop(self):
+        """Arrête proprement le serveur socket."""
+        self.is_running = False
+        if self.server_socket:
+            self.server_socket.close()
+
+
+class SocketClient:
+    """Client TCP rapide pour envoyer et recevoir des données."""
+
+    def __init__(self, host: str = "127.0.0.1", port: int = 65432, buffer_size: int = 4096):
+        self.host = host
+        self.port = port
+        self.buffer_size = buffer_size
+
+    def send(self, message: str, timeout: float = 10.0) -> str:
+        """Envoie un message au serveur et attend la réponse complète.
+
+        :param message: Le texte à envoyer
+        :param timeout: Temps d'attente maximum en secondes
+        :return: La réponse reçue du serveur
+        """
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client_socket:
+            client_socket.settimeout(timeout)
+            client_socket.connect((self.host, self.port))
+            client_socket.sendall(message.encode("utf-8"))
+
+            response = client_socket.recv(self.buffer_size)
+            return response.decode("utf-8")
+
+    def send_stream(self, message: str, timeout: float = 10.0) -> Generator[str, None, None]:
+        """Envoie un message et reçoit la réponse en streaming fragment par fragment."""
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client_socket:
+            client_socket.settimeout(timeout)
+            client_socket.connect((self.host, self.port))
+            client_socket.sendall(message.encode("utf-8"))
+
+            while True:
+                try:
+                    chunk = client_socket.recv(self.buffer_size)
+                    if not chunk:
+                        break
+                    yield chunk.decode("utf-8")
+                except socket.timeout:
+                    break

devflow_tools-0.1.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: devflow-tools
+Version: 0.1.0
+Summary: Un couteau suisse pour créer des CLI stylisées, du réseau TCP et intégrer l'IA.
+Author: Alex
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=12.0.0
+Requires-Dist: google-genai>=0.1.0
+Dynamic: license-file
+
+# DevFlow 🚀
+
+**DevFlow** est un couteau suisse Python pour simplifier la création d'interfaces en ligne de commande (CLI) stylisées, la programmation réseau par Sockets TCP et l'intégration de l'IA (Gemini).
+
+## 📥 Installation
+
+```bash
+pip install devflow-tools
+```
+---
+
+## 👨‍💻 À propos de l'auteur
+
+Projet codé et conçu par **Alex74** (développeur passionné jeune) pour simplifier le développement d'outils CLI et réseau en Python.

devflow_tools-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+devflow/__init__.py,sha256=qbVjXsJO5HOApalR7CAJIJAqddWuU4KKRaTy3cRMjm4,126
+devflow/ai.py,sha256=uOlMsitz32r1rqDhxW6uPXnjjYCOnJTN8JCNEC6W-mo,4094
+devflow/cli.py,sha256=N1ED74DoCjHPwPZs1cSJI9e8cahsTDjgSJz4-J74x64,7591
+devflow/help.py,sha256=8J0dUjyeCWtQDFwLFa5vIOCJPws2Xv9CKLlZ0IBjlFY,6988
+devflow/network.py,sha256=J1bJGxmzYK53ZeT2WZOHstTfjT2eCC85Qx0-JWFu8eg,4681
+devflow_tools-0.1.0.dist-info/licenses/LICENSE,sha256=MgpW6G6qVEvu2-_wYDBomnxsSNEa9wHUn-RsuePNGDQ,1082
+devflow_tools-0.1.0.dist-info/METADATA,sha256=FKvdLOKz6yyisNOULWMqxCbMWI-SpPkU_rOOHRTmzZA,967
+devflow_tools-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+devflow_tools-0.1.0.dist-info/top_level.txt,sha256=hyulEBYO7koyGtocuOHxJi07MjoMQMD72EksFQeX2SY,8
+devflow_tools-0.1.0.dist-info/RECORD,,

devflow_tools-0.1.0.dist-info/WHEEL

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

devflow_tools-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex74
+
+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.

devflow_tools-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devflow