speedy-utils 1.0.2__py3-none-any.whl

speedy/__init__.py

@@ -0,0 +1,35 @@
+from .common.clock import Clock, timef
+from .common.utils_cache import (ICACHE, SPEED_CACHE_DIR, identify, imemoize,
+                                 imemoize_v2, memoize, memoize_v2)
+from .common.utils_io import (dump_json_or_pickle, dump_jsonl, load_by_ext,
+                              load_json_or_pickle)
+from .common.utils_misc import (convert_to_builtin_python, flatten_list,
+                                get_arg_names, is_interactive, mkdir_or_exist)
+from .common.utils_print import fprint, print_table
+from .multi_worker import async_multi_thread, multi_process, multi_thread
+
+__all__ = [
+    "SPEED_CACHE_DIR",
+    "ICACHE",
+    "mkdir_or_exist",
+    "dump_jsonl",
+    "dump_json_or_pickle",
+    "timef",  # Ensure timef is moved to an appropriate module or included here
+    "load_json_or_pickle",
+    "load_by_ext",
+    "identify",
+    "memoize",
+    "imemoize",
+    "imemoize_v2",
+    "flatten_list",
+    "fprint",
+    "get_arg_names",
+    "memoize_v2",
+    "is_interactive",
+    "print_table",
+    "convert_to_builtin_python",
+    "Clock",
+    "multi_thread",
+    "multi_process",
+    "async_multi_thread",
+]

speedy/common/clock.py

@@ -0,0 +1,68 @@
+import time
+from loguru import logger
+
+__all__ = ["Clock"]
+
+
+def timef(func):
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        execution_time = end_time - start_time
+        print(f"{func.__name__} took {execution_time:0.2f} seconds to execute.")
+        return result
+
+    return wrapper
+
+
+class Clock:
+    def __init__(self, start_now=True):
+        self.start_time = None
+        self.time_table = {}
+        self.last_check = None
+        if start_now:
+            self.start()
+        self.pbar_counter = 0
+        self.last_print = time.time()
+
+    def start(self):
+        self.start_time = time.time() if self.start_time is None else self.start_time
+        self.last_check = self.start_time
+
+    def since_start(self):
+        if self.start_time is None:
+            raise ValueError("Clock has not been started.")
+        return time.time() - self.start_time
+
+    def log(self, custom_logger=None):
+        msg = f"Time elapsed: {self.since_start():.2f} seconds."
+        if custom_logger:
+            custom_logger(msg)
+        else:
+            logger.info(msg)
+
+    def since_last_check(self):
+        now = time.time()
+        elapsed = now - self.last_check
+        self.last_check = now
+        return elapsed
+
+    def update(self, name):
+        if not name in self.time_table:
+            self.time_table[name] = 0
+        self.time_table[name] += self.since_last_check()
+
+    def print_table(self, every=1):
+        now = time.time()
+        if now - self.last_print > every:
+            self.pbar_counter += 1
+            total_time = sum(self.time_table.values())
+            desc = "Time table: "
+            for name, t in self.time_table.items():
+                percentage = (t / total_time) * 100
+                desc += "{}: avg_time: {:.2f} s ({:.2f}%), total: {} s".format(
+                    name, t, percentage, total_time
+                )
+            logger.info(desc)
+            self.last_print = now

speedy/common/utils_cache.py

@@ -0,0 +1,170 @@
+# utils/utils_cache.py
+
+import functools
+import inspect
+import os
+import os.path as osp
+import pickle
+import traceback
+from typing import Any, Callable, Dict, List, Optional
+
+import xxhash
+from loguru import logger
+
+from .utils_io import dump_json_or_pickle, load_json_or_pickle
+from .utils_misc import mkdir_or_exist
+
+SPEED_CACHE_DIR = osp.join(osp.expanduser("~"), ".cache/av")
+ICACHE: Dict[str, Any] = {}
+
+
+def identify(x: Any) -> str:
+    """Return an hex digest of the input."""
+    return xxhash.xxh64(pickle.dumps(x), seed=0).hexdigest()
+
+
+def memoize(
+    func: Callable,
+    ignore_self: bool = True,
+    cache_dir: str = SPEED_CACHE_DIR,
+    cache_type: str = ".pkl",
+    verbose: bool = False,
+    cache_key: Optional[str] = None,
+) -> Callable:
+    """Cache result of function call on disk."""
+    assert cache_type in [".pkl", ".json"]
+    if os.environ.get("AV_MEMOIZE_DISABLE", "0") == "1":
+        logger.info("Memoize is disabled")
+        return func
+
+    @functools.wraps(func)
+    def memoized_func(*args, **kwargs):
+        try:
+            arg_names = inspect.getfullargspec(func).args
+            func_source = inspect.getsource(func).replace(" ", "")
+            if cache_key is not None:
+                logger.info(f"Use cache_key={kwargs[cache_key]}")
+                fid = [func_source, kwargs[cache_key]]
+                func_id = identify(fid)
+            elif len(arg_names) > 0 and arg_names[0] == "self" and ignore_self:
+                func_id = identify((func_source, args[1:], kwargs))
+            else:
+                func_id = identify((func_source, args, kwargs))
+
+            cache_path = osp.join(
+                cache_dir, "funcs", func.__name__, f"{func_id}{cache_type}"
+            )
+            mkdir_or_exist(os.path.dirname(cache_path))
+            if osp.exists(cache_path):
+                if verbose:
+                    logger.info(f"Load from cache file: {cache_path}")
+                result = load_json_or_pickle(cache_path)
+            else:
+                result = func(*args, **kwargs)
+                dump_json_or_pickle(result, cache_path)
+            return result
+        except Exception as e:
+            traceback.print_exc()
+            logger.warning(f"Exception: {e}, using default function call")
+            return func(*args, **kwargs)
+
+    return memoized_func
+
+
+def imemoize(func: Callable) -> Callable:
+    """Memoize a function into memory."""
+
+    @functools.wraps(func)
+    def _f(*args, **kwargs):
+        ident_name = identify((inspect.getsource(func), args, kwargs))
+        try:
+            return ICACHE[ident_name]
+        except KeyError:
+            result = func(*args, **kwargs)
+            ICACHE[ident_name] = result
+            return result
+
+    return _f
+
+
+def imemoize_v2(keys: List[str]) -> Callable:
+    """Memoize a function into memory based on specified keys."""
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            arg_names = inspect.getfullargspec(func).args
+            args_dict = dict(zip(arg_names, args))
+            all_args = {**args_dict, **kwargs}
+            key_values = {key: all_args[key] for key in keys if key in all_args}
+            if not key_values:
+                return func(*args, **kwargs)
+
+            ident_name = identify((func.__name__, tuple(sorted(key_values.items()))))
+            try:
+                return ICACHE[ident_name]
+            except KeyError:
+                result = func(*args, **kwargs)
+                ICACHE[ident_name] = result
+                return result
+
+        return wrapper
+
+    return decorator
+
+
+def memoize_v2(keys: List[str], cache_dir: str = SPEED_CACHE_DIR) -> Callable:
+    """Decorator to memoize function results based on specific keys."""
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            args_key_values = {}
+            for i, arg in enumerate(args):
+                arg_name = inspect.getfullargspec(func).args[i]
+                args_key_values[arg_name] = arg
+            args_key_values.update(kwargs)
+
+            values = [args_key_values[key] for key in keys if key in args_key_values]
+            if not values:
+                return func(*args, **kwargs)
+
+            key_id = identify(values)
+            func_source = inspect.getsource(func).replace(" ", "")
+            func_id = identify(func_source)
+            key_names = "_".join(keys)
+            cache_path = osp.join(
+                cache_dir, f"{func.__name__}_{func_id}", f"{key_names}_{key_id}.pkl"
+            )
+            if osp.exists(cache_path):
+                return load_json_or_pickle(cache_path)
+            result = func(*args, **kwargs)
+            dump_json_or_pickle(result, cache_path)
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+def memoize_method(method):
+    """
+    Decorator function to memoize (cache) results of a class method.
+
+    This decorator caches the output of the wrapped method based on its input arguments
+    (both positional and keyword). If the method is called again with the same arguments,
+    it returns the cached result instead of executing the method again.
+
+    Args:
+        method (Callable): The decorated method whose result will be memoized.
+    """
+    cache = {}
+
+    def cached_method(cls, *args, **kwargs):
+        cache_key = identify([args, kwargs])
+        logger.debug("HIT" if cache_key in cache else "MISS")
+        if cache_key not in cache:
+            cache[cache_key] = method(cls, *args, **kwargs)
+        return cache[cache_key]
+
+    return cached_method

speedy/common/utils_io.py

@@ -0,0 +1,111 @@
+# utils/utils_io.py
+
+import json
+import os
+import os.path as osp
+import pickle
+from glob import glob
+from typing import Any, List, Dict, Union
+
+from .utils_misc import mkdir_or_exist
+
+
+def dump_jsonl(list_dictionaries: List[Dict], file_name: str = "output.jsonl") -> None:
+    """
+    Dumps a list of dictionaries to a file in JSON Lines format.
+    """
+    with open(file_name, "w", encoding="utf-8") as file:
+        for dictionary in list_dictionaries:
+            file.write(json.dumps(dictionary, ensure_ascii=False) + "\n")
+
+
+def dump_json_or_pickle(
+    obj: Any, fname: str, ensure_ascii: bool = False, indent: int = 4
+) -> None:
+    """
+    Dump an object to a file, supporting both JSON and pickle formats.
+    """
+    mkdir_or_exist(osp.abspath(os.path.dirname(osp.abspath(fname))))
+    if fname.endswith(".json"):
+        with open(fname, "w", encoding="utf-8") as f:
+            json.dump(obj, f, ensure_ascii=ensure_ascii, indent=indent)
+    elif fname.endswith(".jsonl"):
+        dump_jsonl(obj, fname)
+    elif fname.endswith(".pkl"):
+        with open(fname, "wb") as f:
+            pickle.dump(obj, f)
+    else:
+        raise NotImplementedError(f"File type {fname} not supported")
+
+
+def load_json_or_pickle(fname: str) -> Any:
+    """
+    Load an object from a file, supporting both JSON and pickle formats.
+    """
+    if fname.endswith(".json") or fname.endswith(".jsonl"):
+        with open(fname, "r", encoding="utf-8") as f:
+            return json.load(f)
+    else:
+        with open(fname, "rb") as f:
+            return pickle.load(f)
+
+
+def load_by_ext(
+    fname: Union[str, List[str]], do_memoize: bool = False
+) -> Any:
+    """
+    Load data based on file extension.
+    """
+    from .utils_cache import (
+        memoize,
+    )  # Adjust import based on your actual multi_worker module
+
+    from speedy import multi_process  # Ensure multi_worker is correctly referenced
+
+    try:
+        if isinstance(fname, str) and "*" in fname:
+            paths = glob(fname)
+            paths = sorted(paths)
+            return multi_process(load_by_ext, paths, workers=16)
+        elif isinstance(fname, list):
+            paths = fname
+            return multi_process(load_by_ext, paths, workers=16)
+
+        def load_csv(path: str, **pd_kwargs) -> Any:
+            import pandas as pd
+
+            return pd.read_csv(path, engine="pyarrow", **pd_kwargs)
+
+        def load_txt(path: str) -> List[str]:
+            with open(path, "r", encoding="utf-8") as f:
+                return f.read().splitlines()
+
+        def load_default(path: str) -> Any:
+            if path.endswith(".jsonl") or path.endswith(".json"):
+                try:
+                    return load_json_or_pickle(path)
+                except json.JSONDecodeError as exc:
+                    raise ValueError("JSON decoding failed") from exc
+            return load_json_or_pickle(path)
+
+        handlers = {
+            ".csv": load_csv,
+            ".tsv": load_csv,
+            ".txt": load_txt,
+            ".pkl": load_default,
+            ".json": load_default,
+            ".jsonl": load_default,
+        }
+
+        ext = os.path.splitext(fname)[-1]
+        load_fn = handlers.get(ext)
+
+        if not load_fn:
+            raise NotImplementedError(f"File type {ext} not supported")
+
+        if do_memoize:
+            load_fn = memoize(load_fn)
+
+        return load_fn(fname)
+    except Exception as e:
+        raise ValueError(f"Error {e} while loading {fname}") from e

speedy/common/utils_misc.py

@@ -0,0 +1,46 @@
+# utils/utils_misc.py
+
+import inspect
+import os
+import sys
+from typing import Any, Callable, List
+from IPython import get_ipython
+from openai import BaseModel
+
+
+def mkdir_or_exist(dir_name: str) -> None:
+    """Create a directory if it doesn't exist."""
+    os.makedirs(dir_name, exist_ok=True)
+
+def flatten_list(list_of_lists: List[List[Any]]) -> List[Any]:
+    """Flatten a list of lists into a single list."""
+    return [item for sublist in list_of_lists for item in sublist]
+
+def get_arg_names(func: Callable) -> List[str]:
+    """Retrieve argument names of a function."""
+    return inspect.getfullargspec(func).args
+
+
+
+def is_interactive() -> bool:
+    """Check if the environment is interactive (e.g., Jupyter notebook)."""
+    try:
+        get_ipython()
+        return True
+    except NameError:
+        return len(sys.argv) == 1
+
+
+def convert_to_builtin_python(input_data: Any) -> Any:
+    """Convert input data to built-in Python types."""
+    if isinstance(input_data, dict):
+        return {k: convert_to_builtin_python(v) for k, v in input_data.items()}
+    elif isinstance(input_data, list):
+        return [convert_to_builtin_python(v) for v in input_data]
+    elif isinstance(input_data, (int, float, str, bool, type(None))):
+        return input_data
+    elif isinstance(input_data, BaseModel):
+        data = input_data.model_dump_json()
+        return convert_to_builtin_python(data)
+    else:
+        raise ValueError(f"Unsupported type {type(input_data)}")

speedy/common/utils_print.py

@@ -0,0 +1,138 @@
+# utils/utils_print.py
+
+import copy
+import json
+import pprint
+import textwrap
+from typing import Any, Dict, List, Optional
+
+from IPython.display import HTML, display
+from pandas import get_option
+from tabulate import tabulate
+
+# from .utils_cache import is_interactive_env  # Adjust based on actual implementation
+# from .utils_misc import is_interactive
+
+
+def display_pretty_table_html(data: Dict) -> None:
+    """
+    Display a pretty HTML table in Jupyter notebooks.
+    """
+    table = "<table>"
+    for key, value in data.items():
+        table += f"<tr><td>{key}</td><td>{value}</td></tr>"
+    table += "</table>"
+    display(HTML(table))
+
+def fprint(
+    input_data: Any,
+    key_ignore: Optional[List[str]] = None,
+    key_keep: Optional[List[str]] = None,
+    max_width: int = 100,
+    indent: int = 2,
+    depth: Optional[int] = None,
+    table_format: str = "grid",
+    str_wrap_width: int = 80,
+) -> None:
+    """
+    Pretty print structured data.
+    """
+
+    def is_interactive_env():
+        """Check if the environment is interactive (e.g., Jupyter notebook)."""
+        try:
+            shell = get_option().__class__.__name__
+            return shell == "ZMQInteractiveShell"
+        except NameError:
+            return False
+
+    def remove_keys(d: Dict, keys: List[str]) -> Dict:
+        """Remove specified keys from a dictionary."""
+        for key in keys:
+            parts = key.split(".")
+            sub_dict = d
+            for part in parts[:-1]:
+                sub_dict = sub_dict.get(part, {})
+            sub_dict.pop(parts[-1], None)
+        return d
+
+    def keep_keys(d: Dict, keys: List[str]) -> Dict:
+        """Keep only specified keys in a dictionary."""
+        result = {}
+        for key in keys:
+            parts = key.split(".")
+            sub_source = d
+            sub_result = result
+            for part in parts[:-1]:
+                if part not in sub_source:
+                    break
+                sub_result = sub_result.setdefault(part, {})
+                sub_source = sub_source[part]
+            else:
+                sub_result[parts[-1]] = copy.deepcopy(sub_source.get(parts[-1]))
+        return result
+
+    if hasattr(input_data, "to_dict"):
+        input_data = input_data.to_dict()
+
+    processed_data = copy.deepcopy(input_data)
+
+    if isinstance(processed_data, dict):
+        if key_keep is not None:
+            processed_data = keep_keys(processed_data, key_keep)
+        elif key_ignore is not None:
+            processed_data = remove_keys(processed_data, key_ignore)
+
+        if is_interactive_env():
+            display_pretty_table_html(processed_data)
+            return
+
+    if isinstance(processed_data, dict):
+        table = [[k, v] for k, v in processed_data.items()]
+        print(
+            tabulate(
+                table,
+                headers=["Key", "Value"],
+                tablefmt=table_format,
+                maxcolwidths=[None, max_width],
+            )
+        )
+    elif isinstance(processed_data, str):
+        wrapped_text = textwrap.fill(processed_data, width=str_wrap_width)
+        print(wrapped_text)
+    else:
+        printer = pprint.PrettyPrinter(width=max_width, indent=indent, depth=depth)
+        printer.pprint(processed_data)
+
+
+def print_table(data: Any) -> None:
+    """
+    Print data as a table.
+    """
+
+    def __get_table(data: Any) -> str:
+        if isinstance(data, str):
+            try:
+                data = json.loads(data)
+            except json.JSONDecodeError as exc:
+                raise ValueError("String input could not be decoded as JSON") from exc
+
+        if isinstance(data, list):
+            if all(isinstance(item, dict) for item in data):
+                headers = list(data[0].keys())
+                rows = [list(item.values()) for item in data]
+                return tabulate(rows, headers=headers)
+            else:
+                raise ValueError("List must contain dictionaries")
+
+        if isinstance(data, dict):
+            headers = ["Key", "Value"]
+            rows = list(data.items())
+            return tabulate(rows, headers=headers)
+
+        raise TypeError(
+            "Input data must be a list of dictionaries, a dictionary, or a JSON string"
+        )
+
+    table = __get_table(data)
+    print(table)

speedy/multi_worker.py

@@ -0,0 +1,121 @@
+import inspect
+import os
+from concurrent.futures import ThreadPoolExecutor
+from multiprocessing import Pool
+from typing import Any, Callable, List
+import asyncio
+from loguru import logger
+from tqdm import tqdm
+
+
+def multi_thread(
+    func: Callable,
+    inputs: List[Any],
+    workers: int = 4,
+    verbose: bool = True,
+    desc: str | None = None,
+) -> List[Any]:
+    if desc is None:
+        fn_name = func.__name__
+        try:
+            source_file = inspect.getsourcefile(func) or "<string>"
+            source_line = inspect.getsourcelines(func)[1]
+            file_line = f"{source_file}:{source_line}"
+        except (TypeError, OSError):
+            file_line = "Unknown location"
+        desc = f"{fn_name} at {file_line}"
+
+    with ThreadPoolExecutor(max_workers=workers) as executor:
+        # Use executor.map to apply func to inputs in order
+        map_func = executor.map(func, inputs)
+        if verbose:
+            results = list(tqdm(map_func, total=len(inputs), desc=desc))
+        else:
+            results = list(map_func)
+    return results
+
+
+def _init_pool_processes(func):
+    global _func
+    _func = func
+
+
+def _pool_process_executor(args):
+    # Unpack arguments if necessary
+    if isinstance(args, tuple):
+        return _func(*args)
+    else:
+        return _func(args)
+
+
+def multi_process(
+    func: Callable,
+    inputs: List[Any],
+    workers: int = 16,
+    verbose: bool = True,
+    desc: str = "",
+) -> List[Any]:
+    if not desc:
+        fn_name = func.__name__
+        try:
+            source_file = inspect.getsourcefile(func) or "<string>"
+            source_line = inspect.getsourcelines(func)[1]
+            file_line = f"{source_file}:{source_line}"
+        except (TypeError, OSError):
+            file_line = "Unknown location"
+        desc = f"{fn_name} at {file_line}"
+
+    if os.environ.get("DEBUG", "0") == "1":
+        logger.info("DEBUGGING set num workers to 1")
+        workers = 1
+
+    logger.info("Multi-processing {} | Num samples: {}", desc, len(inputs))
+
+    results = []
+    with Pool(
+        processes=workers, initializer=_init_pool_processes, initargs=(func,)
+    ) as pool:
+        try:
+            if verbose:
+                for result in tqdm(
+                    pool.imap(_pool_process_executor, inputs),
+                    total=len(inputs),
+                    desc=desc,
+                ):
+                    results.append(result)
+            else:
+                results = pool.map(_pool_process_executor, inputs)
+        except Exception as e:
+            logger.error(f"[multiprocess] Error {e}")
+
+    return results
+
+
+async def async_multi_thread(f, inputs, desc="", user_tqdm=True):
+    """
+    Uasge:
+        inputs = list(range(10))
+        def function(i):
+            time.sleep(1)
+            return 1/i
+        results = await amulti_thread(function, inputs)
+    """
+
+    def ensure_output_idx(idx_i):
+        idx, i = idx_i
+        return idx, f(i)
+
+    tasks = [asyncio.to_thread(ensure_output_idx, i) for i in enumerate(inputs)]
+    if not desc:
+        desc = f"{f.__name__}"
+
+    pbar = tqdm(total=len(inputs), desc=desc, disable=not user_tqdm)
+    results = [None] * len(inputs)
+    for task in asyncio.as_completed(tasks):
+        idx, result = await task
+        results[idx] = result
+        pbar.update(1)
+    return results
+
+
+__all__ = ["multi_thread", "multi_process", "async_multi_thread"]

speedy_utils-1.0.2.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: speedy-utils
+Version: 1.0.2
+Summary: Fast and easy-to-use package for data science
+Home-page: https://github.com/anhvth/speedy
+Author: AnhVTH
+Author-email: anhvth.226@gmail.com
+Requires-Dist: numpy
+Requires-Dist: requests
+Requires-Dist: xxhash
+Requires-Dist: loguru
+Requires-Dist: fastcore
+Requires-Dist: debugpy
+Requires-Dist: ipywidgets
+Requires-Dist: jupyterlab
+Requires-Dist: ipdb
+Requires-Dist: scikit-learn
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: tabulate
+Requires-Dist: pydantic
+

speedy_utils-1.0.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+speedy/__init__.py,sha256=BPGiT3ehXK3poEFR-j6dNejnB9GBvkX6IR7ANdD-Qy4,1127
+speedy/multi_worker.py,sha256=kmk_Km6LkOUVntxmPKSYubMXFJBPoLoZW9NVi4UA9kc,3394
+speedy/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+speedy/common/clock.py,sha256=q92SvdJLZyCtuq8C6m7GjS6_foI8yyspsKzeR_M1owo,2033
+speedy/common/utils_cache.py,sha256=_qxGyISJBM-r0NDSUCYSEWnEsqprORdw3yXmIkns1D4,5656
+speedy/common/utils_io.py,sha256=X2zFgVzfYM094auApGjYOO43NgnG5P_g7rOObzPYTrQ,3472
+speedy/common/utils_misc.py,sha256=ooMb0xEjC-HrQSQQCTRlEqcrGTJptmA43azSi6BhiD4,1479
+speedy/common/utils_print.py,sha256=jh_ihzWTEiPpFRiLoj6It8Zo_3tPxYi8MU1J3Nw3vwk,4273
+speedy_utils-1.0.2.dist-info/METADATA,sha256=zCKCFD7z_s67PE93IKWCDk8-fCbgv9pXZSF6uquQyZI,538
+speedy_utils-1.0.2.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+speedy_utils-1.0.2.dist-info/top_level.txt,sha256=eJxFW_gum7StgovqwA4v-9UndgnnWr4kUqcozY-aBmI,7
+speedy_utils-1.0.2.dist-info/RECORD,,

speedy_utils-1.0.2.dist-info/WHEEL

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

speedy_utils-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+speedy