profeyelar 1.0.0__tar.gz

profeyelar-1.0.0/LICENSE

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

profeyelar-1.0.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: profeyelar
+Version: 1.0.0
+Summary: UI-based tool for project end-to-end profiling
+Author: puzzleYOU GmbH
+License-Expression: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: setuptools
+Requires-Dist: requests
+Requires-Dist: memray
+Dynamic: license-file
+
+# Profeyelar
+**Profeyelar** (a.k.a. **Prof. Eyelar** a.k.a. **Professor Eyelar**) is an end-to-end profiling tool for Python projects/services that makes use of a graphical user interface to simplify the profiling process. It is primarily used to profile requests performed against a web server. The interface contains various settings, which The Professor will use to create a container for your service and begin profiling once the Start button is pressed. Prof. Eyelar will then perform requests for the specified URLs and will shut the container down again once finished. The Professor will handle activation and deactivation of the profiling for you once the program runs.
+
+## User Interface
+Prof. Eyelar's interface contains various fields, which affect the profiling or to-be-executed requests.
+- In **Request URLs**, you can write any relative request URLs for The Professor to try. Multiple URLs can be separated by a new line. The URLs must be relative–Prof. Eyelar will build the absolute URLs using the project's base URL when the time is right.
+- **Encode URL Parameters** is a small helper that you can utilize to encode URL parameters when necessary. You can then copy the encoded values and use them in the request URLs.
+- **Repetitions** specifies how many times each request should be executed
+- **Headers** can be used to specify any headers that should be passed along with the requests. The headers should be specified without quotes and multiple headers separated with new lines. A colon must be used between a header and its value. If you wish to pass an empty string as a value, then leave the space after the colon empty.
+  - Example
+    ```
+    Accept-Fruit: apple
+    Accept-Language:
+    Accept-Professor: eyelar
+    ```
+- Profiling with **tracemalloc** and **cProfile** can be activated with the corresponding checkboxes. These profiling options will create `.tracemalloc` and `.cprofile` files, which you can interpret with corresponding tools.
+The last profiling option is self-explanatory and can be used to limit RAM. 
+
+## Requirements
+Professor Eyelar has high standards and can only work for your service if specific criteria are met.
+- **Tkinter**: Profeyelar's interface is created with Tkinter, which will only work for you if a Python version that has been configured for Tkinter has been installed. In Ubuntu, for example, Tkinter is generally not included in the default Python installation, so you may need to install the `python3-tk` package. You can check if Tkinter is installed by writing `import tkinter` in a Python session. The import should succeed without error.
+- **Configuration File**: A configuration file in JSON format must be given when calling Profeyelar from the terminal. This file contains information that The Professor will need in order to be able to create a container for your service and save the profiling results. Refer to [Structure of the Configuration File](#structure-of-the-configuration-file) for info on what this file should look like.
+- **Server**: Since Prof. Eyelar is primarily used to profile requests to a web server, your project needs to have a server that The Professor can send requests to once the container has started.
+- **Docker**: The Professor uses Docker commands to create containers for services and profile them, so the Docker Engine is required
+- **Entrypoint**: Profeyelar requires you to implement a `serve-with-eyelar` entrypoint, in which you prepend the command used to start your server with `$*`. This will insert all the arguments that The Professor passes when calling that entrypoint. These arguments essentially wrap the server start in a call to memray, which will be used to profile while the server is active.
+
+## Structure of the Configuration File
+### Fields
+- **base_url** (`string`, required): Absolute base URL of your service. The Professor will combine the relative request URLs with this base URL to build the absolute request URLs.
+- **name** (`string`, required): The name of your service. The Professor needs it in order to run his commands on the service container he will create.
+- **api_docs_url** (`string` or `null`, required): If your project has API-Docs that can be reached via URL, you can insert the absolute URL here. Prof. Eyelar will then include an `Open API Docs` button in its interface, which will open the corresponding page in your browser. This can be helpful if you need to quickly reference the Docs to formulate API-Calls in the relative request URLs correctly
+- **output_directory** (`string`, required): Where Professor Eyelar should save the profiling results. Important to note is that this refers to a directory in the **profiled container's filesystem**. Therefore, if you want to access the results, you should ensure the output directory path in question is mapped to a specific path on the host system, which you can access after the container has stopped. Otherwise, you would lose the results after the profiling is complete because The Professor will then shut down the container.
+- **retry_count** (`number`, optional, default 30): Specifies how many times The Professor will attempt to reach the built container before giving up and cancelling the profiling session. Changing the value for this setting can make sense for larger projects that may need more time to build and start a container for. Professor Eyelar checks the availability of the service container with a readiness probe, which, if unsuccessful, is repeated as many times as specified by `retry_count`. As soon as one of these probes succeeds, Prof. Eyelar will begin performing the user-specified requests.
+
+### Usage of environment variables in strings
+You can reference available environment variables in `string` values of the configuration file. To do so, you simply wrap the variable name in `$ENV{}`. An example of this can be seen in [Example Configuration File](#example-configuration-file).
+
+### Example Configuration File
+```json
+{
+    "service": {
+        "base_url": "http://$ENV{PROJECT_NAME}.com/",
+        "name": "$ENV{PROJECT_NAME}",
+        "api_docs_url": null
+    },
+    "profiling": {
+        "output_directory": "i/am/a/directory/hehe/",
+        "retry_count": 60
+    }
+}
+```
+
+## Output Files
+Profeyelar can generate up to 3 different types of profile result files, which can be analyzed with corresponding tools
+- **Memray (`.bin`) Files**: Profiling results for memray will always be generated. These files end in `.bin` and have _memray_ in their name. You will need memray in order to generate reports from the data in these files. For more info about memray and the different generable reports, you can refer to their documentation [here](https://bloomberg.github.io/memray/getting_started.html).
+- **Tracemalloc (`.tracemalloc`) Files**: Tracemalloc snapshots will only be generated if the corresponding option is activated in the Profeyelar user interface. These files end in `.tracemalloc`, and results can be viewed with corresponding functions of the [tracemalloc](https://docs.python.org/3/library/tracemalloc.html) module
+- **cProfile (`.cprofile`) Files**: cProfile Stats will only be generated if the corresponding option is activated in the Profeyelar user interface. These files end in `.cprofile`, and results can be interpreted with corresponding tools like [pstats](https://docs.python.org/3.15/library/pstats.html) or [snakeviz](https://pypi.org/project/snakeviz/)
+
+## Note regarding Gevent
+As of time of writing, running memray on gunicorn based servers with `GeventWorker` workers results in an error when the server is stopped. We discovered this by chance when we checked the container logs before Profeyelar had finished the container shutdown process. The error does not seem to prevent The Professor from saving the profiling results and shutting the container down successfully. However, it is good to be aware of this behavior nonetheless. We did not encounter a similar error when running a gunicorn based server with Gthread (`ThreadWorker` workers) instead.

profeyelar-1.0.0/README.md

@@ -0,0 +1,60 @@
+# Profeyelar
+**Profeyelar** (a.k.a. **Prof. Eyelar** a.k.a. **Professor Eyelar**) is an end-to-end profiling tool for Python projects/services that makes use of a graphical user interface to simplify the profiling process. It is primarily used to profile requests performed against a web server. The interface contains various settings, which The Professor will use to create a container for your service and begin profiling once the Start button is pressed. Prof. Eyelar will then perform requests for the specified URLs and will shut the container down again once finished. The Professor will handle activation and deactivation of the profiling for you once the program runs.
+
+## User Interface
+Prof. Eyelar's interface contains various fields, which affect the profiling or to-be-executed requests.
+- In **Request URLs**, you can write any relative request URLs for The Professor to try. Multiple URLs can be separated by a new line. The URLs must be relative–Prof. Eyelar will build the absolute URLs using the project's base URL when the time is right.
+- **Encode URL Parameters** is a small helper that you can utilize to encode URL parameters when necessary. You can then copy the encoded values and use them in the request URLs.
+- **Repetitions** specifies how many times each request should be executed
+- **Headers** can be used to specify any headers that should be passed along with the requests. The headers should be specified without quotes and multiple headers separated with new lines. A colon must be used between a header and its value. If you wish to pass an empty string as a value, then leave the space after the colon empty.
+  - Example
+    ```
+    Accept-Fruit: apple
+    Accept-Language:
+    Accept-Professor: eyelar
+    ```
+- Profiling with **tracemalloc** and **cProfile** can be activated with the corresponding checkboxes. These profiling options will create `.tracemalloc` and `.cprofile` files, which you can interpret with corresponding tools.
+The last profiling option is self-explanatory and can be used to limit RAM. 
+
+## Requirements
+Professor Eyelar has high standards and can only work for your service if specific criteria are met.
+- **Tkinter**: Profeyelar's interface is created with Tkinter, which will only work for you if a Python version that has been configured for Tkinter has been installed. In Ubuntu, for example, Tkinter is generally not included in the default Python installation, so you may need to install the `python3-tk` package. You can check if Tkinter is installed by writing `import tkinter` in a Python session. The import should succeed without error.
+- **Configuration File**: A configuration file in JSON format must be given when calling Profeyelar from the terminal. This file contains information that The Professor will need in order to be able to create a container for your service and save the profiling results. Refer to [Structure of the Configuration File](#structure-of-the-configuration-file) for info on what this file should look like.
+- **Server**: Since Prof. Eyelar is primarily used to profile requests to a web server, your project needs to have a server that The Professor can send requests to once the container has started.
+- **Docker**: The Professor uses Docker commands to create containers for services and profile them, so the Docker Engine is required
+- **Entrypoint**: Profeyelar requires you to implement a `serve-with-eyelar` entrypoint, in which you prepend the command used to start your server with `$*`. This will insert all the arguments that The Professor passes when calling that entrypoint. These arguments essentially wrap the server start in a call to memray, which will be used to profile while the server is active.
+
+## Structure of the Configuration File
+### Fields
+- **base_url** (`string`, required): Absolute base URL of your service. The Professor will combine the relative request URLs with this base URL to build the absolute request URLs.
+- **name** (`string`, required): The name of your service. The Professor needs it in order to run his commands on the service container he will create.
+- **api_docs_url** (`string` or `null`, required): If your project has API-Docs that can be reached via URL, you can insert the absolute URL here. Prof. Eyelar will then include an `Open API Docs` button in its interface, which will open the corresponding page in your browser. This can be helpful if you need to quickly reference the Docs to formulate API-Calls in the relative request URLs correctly
+- **output_directory** (`string`, required): Where Professor Eyelar should save the profiling results. Important to note is that this refers to a directory in the **profiled container's filesystem**. Therefore, if you want to access the results, you should ensure the output directory path in question is mapped to a specific path on the host system, which you can access after the container has stopped. Otherwise, you would lose the results after the profiling is complete because The Professor will then shut down the container.
+- **retry_count** (`number`, optional, default 30): Specifies how many times The Professor will attempt to reach the built container before giving up and cancelling the profiling session. Changing the value for this setting can make sense for larger projects that may need more time to build and start a container for. Professor Eyelar checks the availability of the service container with a readiness probe, which, if unsuccessful, is repeated as many times as specified by `retry_count`. As soon as one of these probes succeeds, Prof. Eyelar will begin performing the user-specified requests.
+
+### Usage of environment variables in strings
+You can reference available environment variables in `string` values of the configuration file. To do so, you simply wrap the variable name in `$ENV{}`. An example of this can be seen in [Example Configuration File](#example-configuration-file).
+
+### Example Configuration File
+```json
+{
+    "service": {
+        "base_url": "http://$ENV{PROJECT_NAME}.com/",
+        "name": "$ENV{PROJECT_NAME}",
+        "api_docs_url": null
+    },
+    "profiling": {
+        "output_directory": "i/am/a/directory/hehe/",
+        "retry_count": 60
+    }
+}
+```
+
+## Output Files
+Profeyelar can generate up to 3 different types of profile result files, which can be analyzed with corresponding tools
+- **Memray (`.bin`) Files**: Profiling results for memray will always be generated. These files end in `.bin` and have _memray_ in their name. You will need memray in order to generate reports from the data in these files. For more info about memray and the different generable reports, you can refer to their documentation [here](https://bloomberg.github.io/memray/getting_started.html).
+- **Tracemalloc (`.tracemalloc`) Files**: Tracemalloc snapshots will only be generated if the corresponding option is activated in the Profeyelar user interface. These files end in `.tracemalloc`, and results can be viewed with corresponding functions of the [tracemalloc](https://docs.python.org/3/library/tracemalloc.html) module
+- **cProfile (`.cprofile`) Files**: cProfile Stats will only be generated if the corresponding option is activated in the Profeyelar user interface. These files end in `.cprofile`, and results can be interpreted with corresponding tools like [pstats](https://docs.python.org/3.15/library/pstats.html) or [snakeviz](https://pypi.org/project/snakeviz/)
+
+## Note regarding Gevent
+As of time of writing, running memray on gunicorn based servers with `GeventWorker` workers results in an error when the server is stopped. We discovered this by chance when we checked the container logs before Profeyelar had finished the container shutdown process. The error does not seem to prevent The Professor from saving the profiling results and shutting the container down successfully. However, it is good to be aware of this behavior nonetheless. We did not encounter a similar error when running a gunicorn based server with Gthread (`ThreadWorker` workers) instead.

profeyelar-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "profeyelar"
+version = "1.0.0"
+description = "UI-based tool for project end-to-end profiling"
+dependencies = [
+    "setuptools",
+    "requests",
+    "memray"
+]
+readme = "README.md"
+authors = [
+    {name = "puzzleYOU GmbH"}
+]
+license = "MIT"
+classifiers = []

profeyelar-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

profeyelar-1.0.0/src/profeyelar/__main__.py

@@ -0,0 +1,62 @@
+"""
+Profeyelar (a.k.a. Prof. Eyelar a.k.a Professor Eyelar) is an end-to-end
+profiling tool for projects.
+"""
+
+import argparse
+import json
+from os.path import isfile
+from tkinter import Tk
+
+from parsing import (ConfigurationParseError, EnvironmentVariableNotFoundError,
+                     parse_setting)
+from ui import MainFrame
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    group = parser.add_argument_group("General")
+
+    group.add_argument(
+        "configuration_file",
+        metavar="configuration-file",
+        type=str,
+        help="""
+        The configuration file with the information that Profeyelar
+        requires in order to profile. This must be a valid JSON file
+        with the structure described in the README.md
+        """,
+    )
+
+    options = parser.parse_args()
+    return options
+
+
+def run_professor():
+    options = parse_args()
+    config_file_path = options.configuration_file
+    if not isfile(config_file_path):
+        raise ConfigurationParseError(config_file_path)
+
+    try:
+        with open(config_file_path, "r") as settings_file:
+            json_settings = json.load(settings_file)
+        prefixed_settings = {
+            f"{prefix}__{key}": parse_setting(value)
+            for prefix in json_settings.keys()
+            for key, value in json_settings[prefix].items()
+        }
+    except KeyError as ke:
+        raise EnvironmentVariableNotFoundError(config_file_path, str(ke))
+    except Exception:
+        raise ConfigurationParseError(config_file_path)
+
+    print("👓 Professor Eyelar is coming, please wait a few seconds... 👓")
+
+    root = Tk()
+    frame = MainFrame(root, prefixed_settings)
+    frame.enter_main_loop()
+
+
+if __name__ == "__main__":
+    run_professor()

profeyelar-1.0.0/src/profeyelar/launcher.py

@@ -0,0 +1,170 @@
+import json
+import traceback
+from contextlib import suppress
+from dataclasses import dataclass
+from functools import reduce
+from http import HTTPStatus
+from pathlib import Path
+from subprocess import PIPE, CalledProcessError, check_output, run
+from time import sleep
+from urllib.parse import urljoin
+from uuid import uuid4
+
+import requests
+from preferences import ProfilingPreferences
+from profiling import CProfileContext, TracemallocContext
+from ui import MainFrame
+
+
+def is_service_running(name: str) -> bool:
+    cmdline = ["docker", "compose", "ps", name, "--format", "json"]
+    if (out := check_output(cmdline).decode()) == "":
+        return False
+    return json.loads(out)["State"] == "running"
+
+
+@dataclass(frozen=True, slots=True)
+class DockerContainer:
+    service_name: str
+    container_name: str
+    command: str
+    command_args: list[str]
+    env: dict[str, str]
+
+    def build(self):
+        cmdline = ["docker", "compose", "build", self.service_name]
+        run(cmdline, stdout=PIPE, stderr=PIPE, check=True)
+
+    def run(self, detached: bool = False):
+        envs = reduce(
+            lambda interim, pair: [*interim, "--env", f"{pair[0]}={pair[1]}"],
+            self.env.items(),
+            [],
+        )
+        maybe_detached = ["-d"] if detached else []
+        cmdline = [
+            "docker",
+            "compose",
+            "run",
+            *maybe_detached,
+            *envs,
+            "--name",
+            self.container_name,
+            self.service_name,
+            self.command,
+            *self.command_args,
+        ]
+
+        try:
+            run(cmdline, stdout=PIPE, stderr=PIPE, check=True)
+        except CalledProcessError as exc:
+            stdout = exc.stdout.decode("utf-8")
+            stderr = exc.stderr.decode("utf-8")
+            text = f"""
+            Starting container failed.
+            cmdline: {cmdline}
+            stdout: {stdout}
+            stderr: {stderr}
+            """
+            raise RuntimeError(text) from exc
+
+    def stop(self):
+        cmdline = ["docker", "container", "stop", self.container_name]
+        run(cmdline, stdout=PIPE, stderr=PIPE, check=True)
+
+
+def start_profiling(
+    parsed_settings: dict, prefs: ProfilingPreferences, ui: MainFrame
+):
+    ui.freeze()
+    service_name = parsed_settings["service__name"]
+    if is_service_running(service_name):
+        ui.notify_err(
+            f"Please stop {service_name} first. The Professor takes care"
+            " of starting it with the expected environment settings."
+        )
+        return
+
+    container = _initialize_container(parsed_settings, prefs)
+    try:
+        ui.set_status_text("Building container...")
+        container.build()
+        ui.set_status_text("Starting container...")
+        container.run(detached=True)
+        ui.set_status_text(f"Waiting until {service_name} wakes up...")
+        _wait_until_container_is_up(parsed_settings)
+        _fire_requests(parsed_settings, prefs, ui)
+    except Exception as e:
+        traceback.print_exception(e)
+        ui.notify_err(f"{e.__class__.__name__}: {e}")
+    finally:
+        ui.set_status_text("Stopping container...")
+        container.stop()
+        ui.unfreeze()
+        ui.set_status_text("Ready")
+
+
+def _initialize_container(
+    parsed_settings: dict,
+    prefs: ProfilingPreferences,
+) -> DockerContainer:
+    service_name = parsed_settings["service__name"]
+    output_path = str(
+        Path(parsed_settings["profiling__output_directory"])
+        / "memray_output.bin"
+    )
+    return DockerContainer(
+        service_name=service_name,
+        container_name=f"{service_name}-{uuid4()}",
+        command="serve-with-eyelar",
+        command_args=[
+            "memray",
+            "run",
+            "-o",
+            output_path,
+            "-f",
+            "--follow-fork",
+            "--native",
+            "--trace-python-allocators",
+        ],
+        env={
+            CProfileContext.associated_env: str(prefs.cprofile_enabled),
+            TracemallocContext.associated_env: str(prefs.tracemalloc_enabled),
+        },
+    )
+
+
+def _wait_until_container_is_up(parsed_settings: dict):
+    max_tries = int(parsed_settings.get("profiling__retry_count", 0)) or 30
+    tries = 0
+    while tries <= max_tries:
+        with suppress(Exception):
+            resp = requests.get(
+                urljoin(
+                    parsed_settings["service__base_url"], "/_/kube/readiness/"
+                )
+            )
+            if resp.status_code == HTTPStatus.OK:
+                return
+        sleep(1)
+        tries += 1
+    raise RuntimeError("retries exhausted")
+
+
+def _fire_requests(
+    parsed_settings: dict, prefs: ProfilingPreferences, ui: MainFrame
+):
+    maximum = prefs.repetitions * len(prefs.relative_urls)
+    request_headers = prefs.request_headers or None
+
+    i = 1
+    for _ in range(prefs.repetitions):
+        for url_path in prefs.relative_urls:
+            ui.set_status_text(f"Performing request {i}/{maximum}...")
+            resp = requests.get(
+                urljoin(parsed_settings["service__base_url"], url_path),
+                headers=request_headers,
+            )
+            if resp.status_code != HTTPStatus.OK:
+                raise RuntimeError(f"ERROR {resp.status_code}: {resp.content}")
+            i += 1

profeyelar-1.0.0/src/profeyelar/parsing.py

@@ -0,0 +1,36 @@
+import os
+import re
+
+
+class ConfigurationParseError(Exception):
+    def __init__(self, settings_file: str):
+        super().__init__(
+            "[ERROR] Profeyelar could not extract the required settings"
+            f" from configuration file {settings_file}. Ensure that the"
+            " .json File exists, is properly formatted and contains all"
+            " required settings."
+        )
+
+
+class EnvironmentVariableNotFoundError(Exception):
+    def __init__(self, settings_file: str, variable: str):
+        super().__init__(
+            "[ERROR] Profeyelar failed to parse the configuration"
+            f" file {settings_file} due to the undefined"
+            f" environment variable {variable}!"
+        )
+
+
+CONFIGURATION_FILE_ENV_REGEX = re.compile(r"\$ENV\{[a-zA-Z0-9_\-]+\}")
+
+
+def parse_setting(value: object):
+    if type(value) is str:
+        env_matches = re.findall(CONFIGURATION_FILE_ENV_REGEX, value)
+        for match in env_matches:
+            value = value.replace(match, get_parsed_env_variable(match))
+    return value
+
+
+def get_parsed_env_variable(text: str) -> str:
+    return os.environ[text.removeprefix("$ENV{").removesuffix("}")]

profeyelar-1.0.0/src/profeyelar/preferences.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class ProfilingPreferences:
+    relative_urls: list[str]
+    repetitions: int
+    tracemalloc_enabled: bool
+    cprofile_enabled: bool
+    ram_limit: int | None
+    request_headers: dict[str, str]

profeyelar-1.0.0/src/profeyelar/profiling.py

@@ -0,0 +1,112 @@
+import logging
+import os
+import tracemalloc
+import types
+from abc import abstractmethod
+from contextlib import AbstractContextManager, contextmanager
+from cProfile import Profile
+from pathlib import Path
+from uuid import uuid4
+
+logger = logging.getLogger(__name__)
+
+
+class ProfilerContext(AbstractContextManager):
+    associated_env: str
+    output_directory: Path
+    enabled: bool
+
+    @abstractmethod
+    def _start_tracing(self): ...
+
+    @abstractmethod
+    def _stop_tracing(self): ...
+
+    @abstractmethod
+    def _save_snapshots(self): ...
+
+    def __init__(
+        self, session_id: str, output_directory: Path, log: bool = False
+    ) -> None:
+        super().__init__()
+        self.session_id = session_id
+        self.enabled = os.environ.get(self.associated_env) == "True"
+        self.output_directory = output_directory
+        if log:
+            logger.info(f"→ {self.associated_env}: {self.enabled}")
+
+    def __enter__(self) -> None:
+        if self.enabled:
+            self._start_tracing()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> bool | None:
+        if self.enabled:
+            self._stop_tracing()
+            self._save_snapshots()
+
+
+class CProfileContext(ProfilerContext):
+    associated_env = "EYELAR_DEBUG_WITH_CPROFILE"
+
+    def __init__(
+        self, session_id: str, output_directory: Path, log: bool = False
+    ):
+        super().__init__(
+            session_id=session_id, output_directory=output_directory, log=log
+        )
+        self.profile = Profile()
+
+    def _start_tracing(self):
+        self.profile.enable()
+
+    def _stop_tracing(self):
+        # Profile.dump_stats() also calls Profile.disable()
+        pass
+
+    def _save_snapshots(self):
+        self.profile.dump_stats(
+            str(self.output_directory / f"{self.session_id}.cprofile")
+        )
+
+
+class TracemallocContext(ProfilerContext):
+    associated_env = "EYELAR_DEBUG_WITH_TRACEMALLOC"
+
+    def __init__(
+        self, session_id: str, output_directory: Path, log: bool = False
+    ):
+        super().__init__(
+            session_id=session_id, output_directory=output_directory, log=log
+        )
+
+    def _start_tracing(self):
+        tracemalloc.start()
+        self.snapshot_start = tracemalloc.take_snapshot()
+
+    def _stop_tracing(self):
+        self.snapshot_end = tracemalloc.take_snapshot()
+        tracemalloc.stop()
+
+    def _save_snapshots(self):
+        self.snapshot_start.dump(
+            str(self.output_directory / f"{self.session_id}.0.tracemalloc")
+        )
+        self.snapshot_end.dump(
+            str(self.output_directory / f"{self.session_id}.1.tracemalloc")
+        )
+
+
+@contextmanager
+def profiling_session_if_enabled(output_directory: Path):
+    session_id = str(uuid4())
+    logger.info(f"profiling session ID: {session_id}")
+    with (
+        CProfileContext(session_id, output_directory, log=True),
+        TracemallocContext(session_id, output_directory, log=True),
+    ):
+        yield

profeyelar-1.0.0/src/profeyelar/ui.py

@@ -0,0 +1,469 @@
+import tkinter
+import tkinter.messagebox
+import traceback
+import urllib.parse
+import webbrowser
+from operator import methodcaller
+from threading import Thread
+from tkinter.scrolledtext import ScrolledText
+
+from preferences import ProfilingPreferences
+
+
+class InvalidTextInputError(Exception):
+    def __init__(self, given_value: str):
+        super().__init__(
+            "[ERROR] The following value is not a valid value"
+            f" for the corresponding input field: {given_value}"
+        )
+
+
+class MainFrame(tkinter.Frame):
+    HEADING_FONT = ("Helvetica", 14)
+    PADDING_SIZE = 10
+    PROGRAM_NAME = "Prof. Eyelar"
+    STANDARD_FONT = ("Helvetica", 10)
+    SPINBOX_WIDTH = 40
+
+    def __init__(self, root: tkinter.Tk, options):
+        super().__init__(
+            root, padx=self.PADDING_SIZE, pady=self.PADDING_SIZE / 2
+        )
+        self._root = root
+        root.title(self.PROGRAM_NAME)
+        self.row_count = 0
+        self.parsed_settings = options
+        self._add_widgets()
+
+    def get_selected_preferences(self) -> ProfilingPreferences:
+        ram_limit = int(self._ram_limit.get())
+        return ProfilingPreferences(
+            relative_urls=self._tell_provided_relative_urls(),
+            repetitions=int(self._repetitions.get()),
+            tracemalloc_enabled=self._tracemalloc_selected.get(),
+            cprofile_enabled=self._cprofile_selected.get(),
+            ram_limit=ram_limit or None,
+            request_headers=self._build_request_headers(),
+        )
+
+    def freeze(self):
+        self._start_button.config(state=tkinter.DISABLED)
+
+    def unfreeze(self):
+        self._start_button.config(state=tkinter.NORMAL)
+
+    def notify_err(self, msg: str):
+        tkinter.messagebox.showerror(
+            self.PROGRAM_NAME, f"Invalid input: {msg}"
+        )
+
+    def _build_request_headers(self) -> dict[str, str]:
+        headers_text = self._get_long_text_content(self._request_headers)
+        lines = self._get_stripped_text_lines(headers_text)
+        if len(lines) != headers_text.count(":"):
+            raise InvalidTextInputError(headers_text)
+        return {
+            key: value.lstrip()
+            for key, value in map(methodcaller("split", ":"), lines)
+        }
+
+    def _tell_provided_relative_urls(self) -> list[str]:
+        full_text = self._get_long_text_content(self._requests)
+        result = self._get_stripped_text_lines(full_text)
+        if not result:
+            raise ValueError("providing no URLs does not quite make sense.")
+        return result
+
+    def _get_long_text_content(self, widget: ScrolledText) -> str:
+        return widget.get(1.0, tkinter.END)
+
+    def _get_stripped_text_lines(self, text: str) -> str:
+        stripped = (line.strip() for line in text.splitlines())
+        return [line for line in stripped if line]
+
+    def _set_encoded_value(self):
+        current = self._unencoded.get()
+        encoded = urllib.parse.quote_plus(current)
+        self._encoded.set(encoded)
+
+    def _add_widgets(self):
+        self.grid()
+        self._set_up_request_url_section()
+        self._set_up_fields_filter_utility_section()
+        self._set_up_request_options_section()
+        self._set_up_profiling_options_section()
+        self._set_up_buttons()
+        self._set_up_status_bar()
+        self.set_status_text("Ready")
+
+    def _start_profiling_with_selected_preferences(self):
+        try:
+            prefs = self.get_selected_preferences()
+            from launcher import start_profiling
+
+            th = Thread(
+                target=start_profiling,
+                args=(self.parsed_settings, prefs, self),
+            )
+            th.start()
+        except ValueError as e:
+            tkinter.messagebox.showerror(
+                self.PROGRAM_NAME, f"Invalid input: {e}"
+            )
+        except Exception as e:
+            traceback.print_exception(e)
+            tkinter.messagebox.showerror(
+                self.PROGRAM_NAME, f"{e.__class__.__name__}: {e}"
+            )
+
+    def _set_up_buttons(self):
+        self.frame_buttons = tkinter.Frame(self)
+        self.frame_buttons.grid(
+            column=0,
+            row=self.row_count,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="ew",
+        )
+        self.frame_buttons.columnconfigure(0, weight=2)
+        self.frame_buttons.columnconfigure(1, weight=1)
+        self.frame_buttons.columnconfigure(2, weight=1)
+
+        self._start_button = tkinter.Button(
+            self.frame_buttons,
+            text="Start container & run requests",
+            command=self._start_profiling_with_selected_preferences,
+        )
+        self._start_button.grid(
+            column=0,
+            row=0,
+            sticky="w",
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+        )
+
+        docs_url = self.parsed_settings["service__api_docs_url"]
+        if docs_url:
+            tkinter.Button(
+                self.frame_buttons,
+                text="Open API docs",
+                command=lambda: webbrowser.open_new_tab(docs_url),
+            ).grid(
+                column=1,
+                row=0,
+                padx=self.PADDING_SIZE,
+                pady=self.PADDING_SIZE / 2,
+                sticky="w",
+            )
+
+        tkinter.Button(
+            self.frame_buttons, text="Quit", command=self._root.destroy
+        ).grid(
+            column=2,
+            row=0,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="e",
+        )
+
+        self._increment_row_count()
+
+    def _set_up_profiling_options_section(self):
+        self.frame_profiling_options = tkinter.Frame(self)
+        self.frame_profiling_options.grid(
+            column=0,
+            row=self.row_count,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="ew",
+        )
+        self.frame_profiling_options.columnconfigure(0, weight=1)
+        self.frame_profiling_options.columnconfigure(1, weight=2)
+
+        tkinter.Label(
+            self.frame_profiling_options,
+            text="Profiling options",
+            justify="left",
+            font=self.HEADING_FONT,
+        ).grid(
+            column=0,
+            row=0,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="w",
+        )
+
+        tkinter.Label(
+            self.frame_profiling_options,
+            text="Enable tracemalloc",
+            font=self.STANDARD_FONT,
+            justify="left",
+        ).grid(
+            column=0,
+            row=1,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="w",
+        )
+        self._tracemalloc_selected = tkinter.BooleanVar()
+        tkinter.Checkbutton(
+            self.frame_profiling_options, variable=self._tracemalloc_selected
+        ).grid(
+            column=1,
+            row=1,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="e",
+        )
+
+        tkinter.Label(
+            self.frame_profiling_options,
+            text="Enable cProfile",
+            font=self.STANDARD_FONT,
+            justify="left",
+        ).grid(
+            column=0,
+            row=2,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="w",
+        )
+        self._cprofile_selected = tkinter.BooleanVar()
+        tkinter.Checkbutton(
+            self.frame_profiling_options, variable=self._cprofile_selected
+        ).grid(
+            column=1,
+            row=2,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="e",
+        )
+
+        tkinter.Label(
+            self.frame_profiling_options,
+            text="Limit RAM to given amount of MiB\n(0 = unlimited)",
+            font=self.STANDARD_FONT,
+            justify="left",
+        ).grid(
+            column=0,
+            row=3,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="nw",
+        )
+        self._ram_limit = tkinter.Spinbox(
+            self.frame_profiling_options,
+            from_=0,
+            increment=16,
+            to=2048,
+            width=self.SPINBOX_WIDTH,
+        )
+        self._ram_limit.grid(
+            column=1,
+            row=3,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="sne",
+        )
+        self._increment_row_count()
+
+    def _set_up_request_options_section(self):
+        self.frame_request_options = tkinter.Frame(self)
+        self.frame_request_options.grid(
+            column=0,
+            row=self.row_count,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="ew",
+        )
+        self.frame_request_options.columnconfigure(0, weight=1)
+        self.frame_request_options.columnconfigure(1, weight=2)
+
+        label_options = tkinter.Label(
+            self.frame_request_options,
+            text="Request options",
+            font=self.HEADING_FONT,
+        )
+        label_options.grid(
+            column=0,
+            row=0,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="w",
+        )
+        tkinter.Label(
+            self.frame_request_options,
+            text="Repetitions",
+            font=self.STANDARD_FONT,
+        ).grid(
+            column=0,
+            row=1,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="w",
+        )
+        self._repetitions = tkinter.Spinbox(
+            self.frame_request_options,
+            from_=1,
+            increment=1,
+            to=1000,
+            width=self.SPINBOX_WIDTH,
+        )
+        self._repetitions.grid(
+            column=1,
+            row=1,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="e",
+        )
+
+        tkinter.Label(
+            self.frame_request_options, text="Headers", font=self.STANDARD_FONT
+        ).grid(
+            column=0,
+            row=2,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="nw",
+        )
+        self._request_headers = ScrolledText(
+            self.frame_request_options, height=3, width=46
+        )
+        self._request_headers.grid(
+            column=1,
+            row=2,
+            sticky="e",
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+        )
+        self._increment_row_count()
+
+    def _set_up_fields_filter_utility_section(self):
+        self.frame_utilities = tkinter.Frame(self)
+        self.frame_utilities.grid(
+            column=0,
+            row=self.row_count,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="ew",
+        )
+        self.frame_utilities.columnconfigure(0, weight=2)
+        self.frame_utilities.columnconfigure(1, weight=1)
+        self.frame_utilities.columnconfigure(2, weight=2)
+
+        tkinter.Label(
+            self.frame_utilities,
+            text="Helper: Encode URL Parameters",
+            font=self.HEADING_FONT,
+        ).grid(
+            column=0,
+            columnspan=3,
+            row=0,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+        )
+        self._unencoded = tkinter.StringVar()
+        tkinter.Entry(
+            self.frame_utilities, textvariable=self._unencoded, width=25
+        ).grid(
+            column=0,
+            row=1,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+        )
+        tkinter.Button(
+            self.frame_utilities,
+            text="→ Encode",
+            command=self._set_encoded_value,
+        ).grid(
+            column=1,
+            row=1,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+        )
+        self._encoded = tkinter.StringVar()
+        tkinter.Entry(
+            self.frame_utilities, textvariable=self._encoded, width=25
+        ).grid(
+            column=2,
+            row=1,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+        )
+        self._increment_row_count()
+
+    def _set_up_request_url_section(self):
+        self.frame_request_urls = tkinter.Frame(self)
+        self.frame_request_urls.grid(
+            column=0,
+            row=self.row_count,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="ew",
+        )
+
+        tkinter.Label(
+            self.frame_request_urls,
+            text="Request URLs",
+            font=self.HEADING_FONT,
+        ).grid(
+            column=0,
+            row=0,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="w",
+        )
+        tkinter.Label(
+            self.frame_request_urls,
+            text=(
+                "Please enter relative request URLs here, "
+                "e. g. /stores/?fields=%5Bid%2Cname%5D"
+            ),
+            font=self.STANDARD_FONT,
+        ).grid(
+            column=0,
+            row=1,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="w",
+        )
+        self._requests = ScrolledText(self.frame_request_urls)
+        self._requests.grid(
+            column=0,
+            row=2,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+        )
+        self._increment_row_count()
+
+    def _set_up_status_bar(self):
+        self.frame_status_bar = tkinter.Frame(self)
+        self.frame_status_bar.grid(
+            column=0,
+            row=self.row_count,
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+            sticky="ew",
+        )
+
+        self._status_bar = tkinter.Label(
+            self.frame_status_bar, text="", font=self.STANDARD_FONT
+        )
+        self._status_bar.grid(
+            column=0,
+            row=0,
+            sticky="w",
+            padx=self.PADDING_SIZE,
+            pady=self.PADDING_SIZE / 2,
+        )
+
+        self._increment_row_count()
+
+    def set_status_text(self, status: str):
+        self._status_bar.config(text=f"STATUS: {status}")
+
+    def enter_main_loop(self):
+        self._root.mainloop()
+
+    def _increment_row_count(self):
+        self.row_count += 1

profeyelar-1.0.0/src/profeyelar.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: profeyelar
+Version: 1.0.0
+Summary: UI-based tool for project end-to-end profiling
+Author: puzzleYOU GmbH
+License-Expression: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: setuptools
+Requires-Dist: requests
+Requires-Dist: memray
+Dynamic: license-file
+
+# Profeyelar
+**Profeyelar** (a.k.a. **Prof. Eyelar** a.k.a. **Professor Eyelar**) is an end-to-end profiling tool for Python projects/services that makes use of a graphical user interface to simplify the profiling process. It is primarily used to profile requests performed against a web server. The interface contains various settings, which The Professor will use to create a container for your service and begin profiling once the Start button is pressed. Prof. Eyelar will then perform requests for the specified URLs and will shut the container down again once finished. The Professor will handle activation and deactivation of the profiling for you once the program runs.
+
+## User Interface
+Prof. Eyelar's interface contains various fields, which affect the profiling or to-be-executed requests.
+- In **Request URLs**, you can write any relative request URLs for The Professor to try. Multiple URLs can be separated by a new line. The URLs must be relative–Prof. Eyelar will build the absolute URLs using the project's base URL when the time is right.
+- **Encode URL Parameters** is a small helper that you can utilize to encode URL parameters when necessary. You can then copy the encoded values and use them in the request URLs.
+- **Repetitions** specifies how many times each request should be executed
+- **Headers** can be used to specify any headers that should be passed along with the requests. The headers should be specified without quotes and multiple headers separated with new lines. A colon must be used between a header and its value. If you wish to pass an empty string as a value, then leave the space after the colon empty.
+  - Example
+    ```
+    Accept-Fruit: apple
+    Accept-Language:
+    Accept-Professor: eyelar
+    ```
+- Profiling with **tracemalloc** and **cProfile** can be activated with the corresponding checkboxes. These profiling options will create `.tracemalloc` and `.cprofile` files, which you can interpret with corresponding tools.
+The last profiling option is self-explanatory and can be used to limit RAM. 
+
+## Requirements
+Professor Eyelar has high standards and can only work for your service if specific criteria are met.
+- **Tkinter**: Profeyelar's interface is created with Tkinter, which will only work for you if a Python version that has been configured for Tkinter has been installed. In Ubuntu, for example, Tkinter is generally not included in the default Python installation, so you may need to install the `python3-tk` package. You can check if Tkinter is installed by writing `import tkinter` in a Python session. The import should succeed without error.
+- **Configuration File**: A configuration file in JSON format must be given when calling Profeyelar from the terminal. This file contains information that The Professor will need in order to be able to create a container for your service and save the profiling results. Refer to [Structure of the Configuration File](#structure-of-the-configuration-file) for info on what this file should look like.
+- **Server**: Since Prof. Eyelar is primarily used to profile requests to a web server, your project needs to have a server that The Professor can send requests to once the container has started.
+- **Docker**: The Professor uses Docker commands to create containers for services and profile them, so the Docker Engine is required
+- **Entrypoint**: Profeyelar requires you to implement a `serve-with-eyelar` entrypoint, in which you prepend the command used to start your server with `$*`. This will insert all the arguments that The Professor passes when calling that entrypoint. These arguments essentially wrap the server start in a call to memray, which will be used to profile while the server is active.
+
+## Structure of the Configuration File
+### Fields
+- **base_url** (`string`, required): Absolute base URL of your service. The Professor will combine the relative request URLs with this base URL to build the absolute request URLs.
+- **name** (`string`, required): The name of your service. The Professor needs it in order to run his commands on the service container he will create.
+- **api_docs_url** (`string` or `null`, required): If your project has API-Docs that can be reached via URL, you can insert the absolute URL here. Prof. Eyelar will then include an `Open API Docs` button in its interface, which will open the corresponding page in your browser. This can be helpful if you need to quickly reference the Docs to formulate API-Calls in the relative request URLs correctly
+- **output_directory** (`string`, required): Where Professor Eyelar should save the profiling results. Important to note is that this refers to a directory in the **profiled container's filesystem**. Therefore, if you want to access the results, you should ensure the output directory path in question is mapped to a specific path on the host system, which you can access after the container has stopped. Otherwise, you would lose the results after the profiling is complete because The Professor will then shut down the container.
+- **retry_count** (`number`, optional, default 30): Specifies how many times The Professor will attempt to reach the built container before giving up and cancelling the profiling session. Changing the value for this setting can make sense for larger projects that may need more time to build and start a container for. Professor Eyelar checks the availability of the service container with a readiness probe, which, if unsuccessful, is repeated as many times as specified by `retry_count`. As soon as one of these probes succeeds, Prof. Eyelar will begin performing the user-specified requests.
+
+### Usage of environment variables in strings
+You can reference available environment variables in `string` values of the configuration file. To do so, you simply wrap the variable name in `$ENV{}`. An example of this can be seen in [Example Configuration File](#example-configuration-file).
+
+### Example Configuration File
+```json
+{
+    "service": {
+        "base_url": "http://$ENV{PROJECT_NAME}.com/",
+        "name": "$ENV{PROJECT_NAME}",
+        "api_docs_url": null
+    },
+    "profiling": {
+        "output_directory": "i/am/a/directory/hehe/",
+        "retry_count": 60
+    }
+}
+```
+
+## Output Files
+Profeyelar can generate up to 3 different types of profile result files, which can be analyzed with corresponding tools
+- **Memray (`.bin`) Files**: Profiling results for memray will always be generated. These files end in `.bin` and have _memray_ in their name. You will need memray in order to generate reports from the data in these files. For more info about memray and the different generable reports, you can refer to their documentation [here](https://bloomberg.github.io/memray/getting_started.html).
+- **Tracemalloc (`.tracemalloc`) Files**: Tracemalloc snapshots will only be generated if the corresponding option is activated in the Profeyelar user interface. These files end in `.tracemalloc`, and results can be viewed with corresponding functions of the [tracemalloc](https://docs.python.org/3/library/tracemalloc.html) module
+- **cProfile (`.cprofile`) Files**: cProfile Stats will only be generated if the corresponding option is activated in the Profeyelar user interface. These files end in `.cprofile`, and results can be interpreted with corresponding tools like [pstats](https://docs.python.org/3.15/library/pstats.html) or [snakeviz](https://pypi.org/project/snakeviz/)
+
+## Note regarding Gevent
+As of time of writing, running memray on gunicorn based servers with `GeventWorker` workers results in an error when the server is stopped. We discovered this by chance when we checked the container logs before Profeyelar had finished the container shutdown process. The error does not seem to prevent The Professor from saving the profiling results and shutting the container down successfully. However, it is good to be aware of this behavior nonetheless. We did not encounter a similar error when running a gunicorn based server with Gthread (`ThreadWorker` workers) instead.

profeyelar-1.0.0/src/profeyelar.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/profeyelar/__init__.py
+src/profeyelar/__main__.py
+src/profeyelar/launcher.py
+src/profeyelar/parsing.py
+src/profeyelar/preferences.py
+src/profeyelar/profiling.py
+src/profeyelar/ui.py
+src/profeyelar.egg-info/PKG-INFO
+src/profeyelar.egg-info/SOURCES.txt
+src/profeyelar.egg-info/dependency_links.txt
+src/profeyelar.egg-info/requires.txt
+src/profeyelar.egg-info/top_level.txt

profeyelar-1.0.0/src/profeyelar.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

profeyelar-1.0.0/src/profeyelar.egg-info/requires.txt

@@ -0,0 +1,3 @@
+setuptools
+requests
+memray

profeyelar-1.0.0/src/profeyelar.egg-info/top_level.txt

@@ -0,0 +1 @@
+profeyelar