model-compose 0.1.4__tar.gz → 0.1.5__tar.gz

{model_compose-0.1.4 → model_compose-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.1.4
+Version: 0.1.5
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator (part of the Mindor project)
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.1.4 → model_compose-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.1.4"
+version = "0.1.5"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator (part of the Mindor project)"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/component/engine/context.py

@@ -14,8 +14,8 @@ class ComponentContext:
     def register_source(self, key: str, source: Any) -> None:
         self.sources[key] = source
 
-    async def render_template(self, data: Dict[str, Any]) -> Any:
-        return await self.renderer.render(data)
+    async def render_template(self, data: Dict[str, Any], ignore_files: bool = False) -> Any:
+        return await self.renderer.render(data, ignore_files)
 
     async def _resolve_source(self, key: str) -> Any:
         if key in self.sources:

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/component/engine/http_client.py

@@ -88,7 +88,7 @@ class HttpClientAction:
             result = await self._handle_completion(self.config.completion, context)
             context.register_source("result", result)
 
-        return (await context.render_template(self.config.output)) if self.config.output else (result or response)
+        return (await context.render_template(self.config.output, ignore_files=True)) if self.config.output else (result or response)
 
     async def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/controller/webui/gradio.py

@@ -1,8 +1,10 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
 from mindor.dsl.schema.workflow import WorkflowVariableConfig, WorkflowVariableGroupConfig
-from mindor.core.utils.http_client import HttpClient, HttpStreamResource
+from mindor.core.utils.streaming import StreamResource, Base64StreamResource
+from mindor.core.utils.streaming import save_stream_to_temporary_file
+from mindor.core.utils.http_request import create_upload_file
+from mindor.core.utils.http_client import HttpClient
 from mindor.core.utils.image import load_image_from_stream
-from mindor.core.utils.streaming import Base64StreamResource, save_stream_to_temporary_file
 from .schema import WorkflowSchema
 from starlette.datastructures import UploadFile
 import gradio as gr
@@ -46,7 +48,7 @@ class GradioWebUIBuilder:
                 output_components = gr.Textbox(label="", lines=8, interactive=False, show_copy_button=True)
 
             async def _run_workflow(*args):
-                input = self._build_input_values(args, workflow.input)
+                input = await self._build_input_values(args, workflow.input)
                 output = await runner(input)
                 output = await self._flatten_output_values(output, workflow.output)
                 return output[0] if len(output) == 1 else output
@@ -60,11 +62,11 @@ class GradioWebUIBuilder:
         return section
 
     def _build_input_component(self, variable: WorkflowVariableConfig) -> gr.Component:
-        label = variable.name + (" *" if variable.required else "") + (f" (default: {variable.default})" if variable.default else "")
+        label = (variable.name or "") + (" *" if variable.required else "") + (f" (default: {variable.default})" if variable.default else "")
         info = variable.description or ""
         default = variable.default
 
-        if variable.type == "string":
+        if variable.type == "string" or variable.format in [ "base64", "url" ]:
             return gr.Textbox(label=label, value="", info=info)
 
         if variable.type == "number":
@@ -93,30 +95,24 @@ class GradioWebUIBuilder:
 
         return gr.Textbox(label=label, value=default, info=f"Unsupported type: {variable.type}")
     
-    def _build_input_values(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
+    async def _build_input_values(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
         if len(variables) == 1 and not variables[0].name:
             return arguments[0]
 
         input: Dict[str, Any] = {}
         
         for value, variable in zip(arguments, variables):
-            input[variable.name] = self._convert_input_value(value, variable)
+            input[variable.name] = await self._convert_input_value(value, variable.type, variable.subtype, variable.format, variable.internal)
 
         return input
-    
-    def _convert_input_value(self, value: Any, variable: WorkflowVariableConfig) -> Any:
-        if variable.type in [ "image", "audio", "video", "file" ]:
-            file, filename = open(value, "rb"), os.path.basename(value)
-            headers = { 
-                "Content-Type": self._guess_file_content_type(filename, variable),
-                "Content-Disposition": f'form-data; filename="{filename}"'
-            }
-            return UploadFile(file=file, filename=filename, headers=headers)
+
+    async def _convert_input_value(self, value: Any, type: Optional[str], subtype: Optional[str], format: Optional[str], internal: bool) -> Any:
+        if type in [ "image", "audio", "video", "file" ] and (not internal or not format):
+            if internal and format and format != "path":
+                value = await self._save_value_to_temporary_file(value, subtype, format)
+            return create_upload_file(value, type, subtype)
 
         return value if value != "" else None
-    
-    def _guess_file_content_type(self, filename: str, variable: WorkflowVariableConfig) -> str:
-        return "application/octet-stream"
 
     def _build_output_component(self, variable: Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]) -> Union[gr.Component, List[ComponentGroup]]:
         if isinstance(variable, WorkflowVariableGroupConfig):
@@ -131,15 +127,15 @@ class GradioWebUIBuilder:
         label = variable.name or ""
         info = variable.description or ""
 
-        if variable.type == "string":
+        if variable.type in [ "string", "base64" ]:
             return gr.Textbox(label=label, interactive=False, show_copy_button=True, info=info)
 
         if variable.type == "image":
             return gr.Image(label=label, interactive=False)
-        
+
         if variable.type == "audio":
             return gr.Audio(label=label)
-    
+
         if variable.type == "video":
             return gr.Video(label=label)
 
@@ -164,31 +160,41 @@ class GradioWebUIBuilder:
                     flattened.extend(await self._flatten_output_values(value, variable.variables))
             else:
                 value = output[variable.name] if variable.name else output
-                flattened.append(await self._convert_type(value, variable.type, variable.subtype, variable.format))
+                flattened.append(await self._convert_output_value(value, variable.type, variable.subtype, variable.format, variable.internal))
         return flattened
 
-    async def _convert_type(self, value: Any, type: Optional[str], subtype: Optional[str], format: Optional[str]) -> Any:
+    async def _convert_output_value(self, value: Any, type: Optional[str], subtype: Optional[str], format: Optional[str], internal: bool) -> Any:
         if type == "string":
-            if isinstance(value, (dict, list)):
-                return json.dumps(value)
-            return str(value)
+            return json.dumps(value) if isinstance(value, (dict, list)) else str(value)
 
         if type == "image":
-            if format == "url" and isinstance(value, str):
-                return await load_image_from_stream(await HttpClient().request(value), subtype)
-            if format == "base64" and isinstance(value, str):
-                return await load_image_from_stream(Base64StreamResource(value), subtype)
-            if isinstance(value, HttpStreamResource):
-                return await load_image_from_stream(value, subtype)
-            return None
+            return await self._load_image_from_value(value, subtype, format)
 
         if type in [ "audio", "video" ]:
-            if format == "url" and isinstance(value, str):
-                return await save_stream_to_temporary_file(await HttpClient().request(value), subtype)
-            if format == "base64" and isinstance(value, str):
-                return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
-            if isinstance(value, HttpStreamResource):
-                return await save_stream_to_temporary_file(value, subtype)
-            return None
+            return await self._save_value_to_temporary_file(value, subtype, format)
 
         return value
+
+    async def _load_image_from_value(self, value: Any, subtype: Optional[str], format: Optional[str]) -> Optional[str]:
+        if format == "base64" and isinstance(value, str):
+            return await load_image_from_stream(Base64StreamResource(value), subtype)
+
+        if format == "url" and isinstance(value, str):
+            return await load_image_from_stream(await HttpClient().request(value), subtype)
+
+        if isinstance(value, StreamResource):
+            return await load_image_from_stream(value, subtype)
+
+        return None
+
+    async def _save_value_to_temporary_file(self, value: Any, subtype: Optional[str], format: Optional[str]) -> Optional[str]:
+        if format == "base64" and isinstance(value, str):
+            return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
+
+        if format == "url" and isinstance(value, str):
+            return await save_stream_to_temporary_file(await HttpClient().request(value), subtype)
+
+        if isinstance(value, StreamResource):
+            return await save_stream_to_temporary_file(value, subtype)
+
+        return None

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/controller/webui/schema.py

@@ -5,12 +5,13 @@ from mindor.dsl.schema.component import ComponentConfig
 import re, json
 
 class WorkflowVariable:
-    def __init__(self, name: Optional[str], type: str, subtype: Optional[str], format: Optional[str], default: Optional[Any]):
+    def __init__(self, name: Optional[str], type: str, subtype: Optional[str], format: Optional[str], default: Optional[Any], internal: bool = False):
         self.name: Optional[str] = name
         self.type: str = type
         self.subtype: Optional[str] = subtype
         self.format: Optional[str] = format
         self.default: Optional[Any] = default
+        self.internal: bool = internal
 
     def to_dict(self) -> Dict[str, Any]:
         return {
@@ -18,7 +19,8 @@ class WorkflowVariable:
             "type": self.type,
             "subtype": self.subtype,
             "format": self.format,
-            "default": self.default
+            "default": self.default,
+            "internal": self.internal
         }
 
     def __eq__(self, other):
@@ -52,7 +54,7 @@ class WorkflowVariableResolver:
             "keypath": re.compile(r"[-_\w]+|\[\d+\]"),
         }
 
-    def _enumerate_input_variables(self, value: Any, wanted_key: str) -> List[WorkflowVariable]:
+    def _enumerate_input_variables(self, value: Any, wanted_key: str, internal: bool = False) -> List[WorkflowVariable]:
         if isinstance(value, str):
             variables: List[WorkflowVariable] = []
 
@@ -63,22 +65,22 @@ class WorkflowVariableResolver:
                     default = self._parse_as_type(default, type)
 
                 if key == wanted_key:
-                    variables.append(WorkflowVariable(path, type or "string", subtype, format, default))
+                    variables.append(WorkflowVariable(path, type or "string", subtype, format, default, internal))
 
             return variables
 
         if isinstance(value, BaseModel):
-            return self._enumerate_input_variables(value.model_dump(exclude_none=True), wanted_key)
+            return self._enumerate_input_variables(value.model_dump(exclude_none=True), wanted_key, internal)
         
         if isinstance(value, dict):
-            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value.values() ], [])
+            return sum([ self._enumerate_input_variables(v, wanted_key, internal) for v in value.values() ], [])
 
         if isinstance(value, list):
-            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value ], [])
+            return sum([ self._enumerate_input_variables(v, wanted_key, internal) for v in value ], [])
         
         return []
 
-    def _enumerate_output_variables(self, name: Optional[str], value: Any) -> List[WorkflowVariable]:
+    def _enumerate_output_variables(self, name: Optional[str], value: Any, internal: bool = False) -> List[WorkflowVariable]:
         variables: List[WorkflowVariable] = []
         
         if isinstance(value, str):
@@ -88,18 +90,18 @@ class WorkflowVariableResolver:
                 if type and default:
                     default = self._parse_as_type(default, type)
 
-                variables.append(WorkflowVariable(name, type or "string", subtype, format, default))
+                variables.append(WorkflowVariable(name, type or "string", subtype, format, default, internal))
             
             return variables
         
         if isinstance(value, BaseModel):
-            return self._enumerate_output_variables(name, value.model_dump(exclude_none=True))
+            return self._enumerate_output_variables(name, value.model_dump(exclude_none=True), internal)
         
         if isinstance(value, dict):
-            return sum([ self._enumerate_output_variables(f"{name}.{k}" if name else f"{k}", v) for k, v in value.items() ], [])
+            return sum([ self._enumerate_output_variables(f"{name}.{k}" if name else f"{k}", v, internal) for k, v in value.items() ], [])
 
         if isinstance(value, list):
-            return sum([ self._enumerate_output_variables(f"{name}[{i}]" if name else f"[{i}]", v) for i, v in enumerate(value) ], [])
+            return sum([ self._enumerate_output_variables(f"{name}[{i}]" if name else f"[{i}]", v, internal) for i, v in enumerate(value) ], [])
         
         return []
 
@@ -126,7 +128,7 @@ class WorkflowVariableResolver:
     def _to_variable_config(self, variable: WorkflowVariable) -> WorkflowVariableConfig:
         config_dict = variable.to_dict()
 
-        if variable.type == "select" and variable.subtype:
+        if variable.type in [ "image", "audio", "video", "file", "select" ] and variable.subtype:
             config_dict["options"] = variable.subtype.split(",")
 
         return WorkflowVariableConfig(**config_dict)
@@ -156,9 +158,13 @@ class WorkflowInputVariableResolver(WorkflowVariableResolver):
                 if isinstance(job.component, str):
                     component: Optional[ComponentConfig] = components[job.component] if job.component in components else None
                     if component:
-                        variables.extend(self._enumerate_input_variables(component.actions[action_id], "input"))
+                        action = component.actions[action_id] if action_id in component.actions else None
+                        if action:
+                            variables.extend(self._enumerate_input_variables(action, "input", internal=True))
                 else:
-                    variables.extend(self._enumerate_input_variables(job.component.actions[action_id], "input"))
+                    action = job.component.actions[action_id] if action_id in job.component.actions else None
+                    if action:
+                        variables.extend(self._enumerate_input_variables(action, "input", internal=True))
             else:
                 variables.extend(self._enumerate_input_variables(job.input, "input"))
 
@@ -186,9 +192,13 @@ class WorkflowOutputVariableResolver(WorkflowVariableResolver):
                 if isinstance(job.component, str):
                     component: Optional[ComponentConfig] = components[job.component] if job.component in components else None
                     if component:
-                        job_variables.extend(self._enumerate_output_variables(None, component.actions[action_id].output))
+                        action = component.actions[action_id] if action_id in component.actions else None
+                        if action:
+                            job_variables.extend(self._enumerate_output_variables(None, action.output, internal=True))
                 else:
-                    job_variables.extend(self._enumerate_output_variables(None, job.component.actions[action_id].output))
+                    action = job.component.actions[action_id] if action_id in job.component.actions else None
+                    if action:
+                        job_variables.extend(self._enumerate_output_variables(None, action.output, internal=True))
             else:
                 job_variables.extend(self._enumerate_output_variables(None, job.output))
 

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/listener/engine/http_callback.py

@@ -25,8 +25,8 @@ class HttpCallbackContext:
         async for item in self._items():
             yield HttpCallbackContext(item, self.query, False, None)
 
-    async def render_template(self, template: str) -> Any:
-        return await self.renderer.render(template)
+    async def render_template(self, template: str, ignore_files: bool = True) -> Any:
+        return await self.renderer.render(template, ignore_files)
 
     async def _items(self) -> List[Any]:
         item = await self.renderer.render(self.item) if self.item else self.body
@@ -78,7 +78,7 @@ class HttpCallbackListener(ListenerEngine):
 
                 if future:
                     if succeeded:
-                        future.set_result((await item.render_template(callback.result)) if callback.result else item.body)
+                        future.set_result((await item.render_template(callback.result, ignore_files=True)) if callback.result else item.body)
                     else:
                         future.set_exception(RuntimeError(f"Task failed for '{callback_id}'"))
                     self._remove_pending_future(callback_id)

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/utils/http_request.py

@@ -3,7 +3,7 @@ from requests.structures import CaseInsensitiveDict
 from starlette.datastructures import FormData, UploadFile
 from urllib.parse import urlencode
 from fastapi import Request
-import aiohttp, re, json
+import aiohttp, re, json, os
 
 _token_pattern = r"([\w!#$%&'*+\-.^_`|~]+)"
 _quoted_pattern = r'"([^"]*)"'
@@ -101,3 +101,21 @@ def parse_options_header(headers: Dict[str, str], header_name: str) -> Tuple[str
         options = {}
 
     return value.strip().lower(), options
+
+def create_upload_file(path: str, type: Optional[str], subtype: Optional[str]) -> UploadFile:
+    file, filename = open(path, "rb"), os.path.basename(path)
+    content_type = guess_file_content_type(filename, type, subtype)
+    headers = { 
+        "Content-Type": content_type,
+        "Content-Disposition": f'form-data; filename="{filename}"'
+    }
+
+    return UploadFile(file=file, filename=filename, headers=headers)
+
+def guess_file_content_type(filename: str, type: Optional[str], subtype: Optional[str]) -> str:
+    subtype = filename.split(".")[-1] if not subtype else subtype
+    
+    if type in [ "image", "audio", "video" ] and subtype:
+        return f"{type}/{subtype}"
+
+    return "application/octet-stream"

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/utils/streaming.py

@@ -1,7 +1,8 @@
 from typing import Optional, AsyncIterator
 from abc import ABC, abstractmethod
 from tempfile import NamedTemporaryFile
-import io, base64
+from aiofiles.threadpool.binary import AsyncBufferedReader
+import aiofiles, io, base64
 
 class StreamResource(ABC):
     def __init__(self, content_type: Optional[str], filename: Optional[str]):
@@ -29,7 +30,12 @@ class Base64StreamResource(StreamResource):
     def __init__(self, encoded: str, content_type: Optional[str] = None, filename: Optional[str] = None):
         super().__init__(content_type, filename)
 
-        self.stream: Optional[io.BytesIO] = io.BytesIO(base64.b64decode(encoded))
+        self.encoded: str = encoded
+        self.stream: Optional[io.BytesIO] = None
+
+    async def __aenter__(self):
+        self.stream = io.BytesIO(base64.b64decode(self.encoded))
+        return self
 
     async def close(self):
         self.stream.close()

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/utils/template.py

@@ -1,6 +1,10 @@
 from typing import Callable, Dict, List, Optional, Awaitable, Any
-from .streaming import StreamResource, encode_stream_to_base64
-import re, json, base64
+from .streaming import StreamResource, Base64StreamResource
+from .streaming import encode_stream_to_base64, save_stream_to_temporary_file
+from .http_request import create_upload_file
+from .http_client import HttpClient
+from starlette.datastructures import UploadFile
+import re, json, base64, os
 
 class TemplateRenderer:
     def __init__(self, source_resolver: Callable[[str], Awaitable[Any]]):
@@ -18,22 +22,22 @@ class TemplateRenderer:
             "keypath": re.compile(r"[-_\w]+|\[\d+\]"),
         }
 
-    async def render(self, data: Any) -> Any:
-        return await self._render_element(data)
+    async def render(self, data: Any, ignore_files: bool = True) -> Any:
+        return await self._render_element(data, ignore_files)
 
-    async def _render_element(self, element: Any) -> Any:
+    async def _render_element(self, element: Any, ignore_files: bool) -> Any:
         if isinstance(element, str):
-            return await self._render_text(element)
+            return await self._render_text(element, ignore_files)
         
         if isinstance(element, dict):
-            return { key: await self._render_element(value) for key, value in element.items() }
+            return { key: await self._render_element(value, ignore_files) for key, value in element.items() }
         
         if isinstance(element, list):
-            return [ await self._render_element(item) for item in element ]
+            return [ await self._render_element(item, ignore_files) for item in element ]
         
         return element
 
-    async def _render_text(self, text: str) -> Any:
+    async def _render_text(self, text: str, ignore_files: bool) -> Any:
         while True:
             match = self.patterns["variable"].search(text)
             
@@ -49,7 +53,7 @@ class TemplateRenderer:
             value = default if value is None else value
 
             if type and value is not None:
-                value = await self._convert_type(value, type, subtype, format)
+                value = await self._convert_value_to_type(value, type, subtype, format, ignore_files)
 
             if variable == text:
                 return value
@@ -79,7 +83,7 @@ class TemplateRenderer:
         
         return current
 
-    async def _convert_type(self, value: Any, type: str, subtype: str, format: Optional[str]) -> Any:
+    async def _convert_value_to_type(self, value: Any, type: str, subtype: str, format: Optional[str], ignore_files: bool) -> Any:
         if type == "number":
             return float(value)
 
@@ -97,4 +101,23 @@ class TemplateRenderer:
                 return await encode_stream_to_base64(value)
             return base64.b64encode(value)
 
+        if type in [ "image", "audio", "video", "file" ]:
+            if not ignore_files and not isinstance(value, UploadFile):
+                if format != "path":
+                    value = await self._save_value_to_temporary_file(value, subtype, format)
+                return create_upload_file(value, type, subtype)
+            return value
+
         return value
+
+    async def _save_value_to_temporary_file(self, value: Any, subtype: Optional[str], format: Optional[str]) -> Optional[str]:
+        if format == "base64" and isinstance(value, str):
+            return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
+
+        if format == "url" and isinstance(value, str):
+            return await save_stream_to_temporary_file(await HttpClient().request(value), subtype)
+
+        if isinstance(value, StreamResource):
+            return await save_stream_to_temporary_file(value, subtype)
+
+        return None

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/workflow/context.py

@@ -16,8 +16,8 @@ class WorkflowContext:
     def register_source(self, key: str, source: Any) -> None:
         self.sources[key] = source
 
-    async def render_template(self, data: Dict[str, Any]) -> Any:
-        return await self.renderer.render(data)
+    async def render_template(self, data: Dict[str, Any], ignore_files: bool = True) -> Any:
+        return await self.renderer.render(data, ignore_files)
 
     async def _resolve_source(self, key: str) -> Any:
         if key in self.sources:

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/core/workflow/job.py

@@ -25,7 +25,7 @@ class Job:
             output = await component.run(await context.render_template(self.config.action), call_id, input)
             context.register_source("output", output)
 
-            output = (await context.render_template(self.config.output)) if self.config.output else output
+            output = (await context.render_template(self.config.output, ignore_files=True)) if self.config.output else output
             outputs.append(output)
 
         repeat_count = (await context.render_template(self.config.repeat_count)) if self.config.repeat_count else None

{model_compose-0.1.4 → model_compose-0.1.5}/src/mindor/dsl/schema/workflow.py

@@ -47,10 +47,11 @@ class WorkflowVariableConfig(BaseModel):
     type: WorkflowVariableType = Field(..., description="Type of the variable")
     subtype: Optional[str] = Field(default=None, description="Subtype of the variable")
     format: Optional[WorkflowVariableFormat] = Field(default=None, description="Format of the variable")
-    options: Optional[List[str]] = Field(default=None, description="List of valid options for select type")
+    options: Optional[List[str]] = Field(default=None, description="List of valid options for file or select type")
     required: bool = Field(default=False, description="Whether this variable is required")
     default: Optional[Any] = Field(default=None, description="Default value if not provided")
     description: Optional[str] = Field(default=None, description="Description of the variable")
+    internal: bool = Field(default=False, description="Whether this variable is for internal use")
 
 class WorkflowVariableGroupConfig(BaseModel):
     name: Optional[str] = Field(default=None, description="The name of the group of variables")

{model_compose-0.1.4 → model_compose-0.1.5}/src/model_compose.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.1.4
+Version: 0.1.5
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator (part of the Mindor project)
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT