mover 0.1.0__py3-none-any.whl

mover/pipeline.py

@@ -0,0 +1,323 @@
+import json
+import argparse
+import subprocess
+import traceback
+from typing import Dict, Any
+from pathlib import Path
+import yaml
+from mover.synthesizers.animation_synthesizer import AnimationSynthesizer
+from mover.synthesizers.mover_synthesizer import MoverSynthesizer
+from mover.dsl.mover_verifier import MoverVerifier
+from mover.converter.mover_converter import convert_animation
+
+
+class AnimationPipeline:
+    """Main pipeline class for handling animation generation and verification."""
+    
+    def __init__(self, config: Dict[str, Any]):
+        """Initialize pipeline with configuration.
+        
+        Args:
+            config: Dictionary containing pipeline configuration
+        """
+        ## Store config
+        self.config = config
+        
+        ## Initialize synthesizers and verifier
+        self.animation_synthesizer = self._init_synthesizer(
+            AnimationSynthesizer,
+            self.config['animation_model']
+        )
+        self.mover_synthesizer = self._init_synthesizer(
+            MoverSynthesizer,
+            self.config['mover_model']
+        )
+        self.verifier = MoverVerifier()
+
+
+    def _init_synthesizer(self, synthesizer_class: Any, config: Dict[str, Any]) -> Any:
+        """Initialize a synthesizer with its configuration.
+        
+        Args:
+            synthesizer_class: The synthesizer class to instantiate
+            config: Configuration dictionary for the synthesizer
+            
+        Returns:
+            Initialized synthesizer instance
+        """
+        params = {k: v for k, v in config.get('params', {}).items() if v is not None}
+        if config.get('vllm_serve_port') is not None:
+            params['vllm_serve_port'] = config['vllm_serve_port']
+        
+        return synthesizer_class(
+            model_name=config['name'],
+            provider=config['provider'],
+            num_ctx=config.get('num_ctx', 128000),
+            params=params
+        )
+
+
+    def _write_log(self, log_path: Path, status: str, num_iter: int, message: str = "") -> None:
+        """Write a log file with consistent formatting.
+        
+        Args:
+            log_path: Path to write the log file
+            status: Status of the run (success/fail/error)
+            num_iter: Number of iterations taken
+            message: Optional additional message to include
+        """
+        with open(log_path, "w") as f:
+            if message:
+                f.write(f"{message}\n\n")
+            
+            f.write(f"Prompt {log_path.parent.name} {status} in {num_iter} iterations.\n")
+            
+            ## Log all config sections
+            for section, values in self.config.items():
+                f.write(f"\n[{section}]\n")
+                for key, value in values.items():
+                    f.write(f"{key}: {value}\n")
+
+
+    def _save_chat_messages(self, chat_file_path: Path, chat_messages: list) -> None:
+        with open(chat_file_path, "w") as f:
+            json.dump(chat_messages, f, indent=4)
+
+
+    def run_loop(self, animation_prompt_data: Dict[str, Any]) -> None:
+        """Run the main chat loop for animation generation and verification.
+        
+        Args:
+            animation_prompt_data: Data about the animation prompt including the prompt text,
+                                 chat ID, and optional ground truth program
+        """
+        chat_id_name = animation_prompt_data["chat_id_name"]
+        animation_prompt = animation_prompt_data["animation_prompt"]
+        paths_config = self.config['paths']
+        
+        chat_dir_path = Path(paths_config['parent_dir']) / chat_id_name
+        chat_file_path = chat_dir_path / f"{chat_id_name}.json"
+        
+        if "svg_file_path" not in animation_prompt_data:
+            svg_file_path = Path(paths_config['svg_dir']) / animation_prompt_data["svg_name"]
+            animation_prompt_data["svg_file_path"] = str(svg_file_path)
+        
+        ## Setup chat directory
+        if not chat_dir_path.exists():
+            chat_dir_path.mkdir(parents=True)
+        else:
+            if any(f.suffix == '.log' for f in chat_dir_path.iterdir()):
+                print(f"Prompt {chat_id_name} has already been run. Skipping.")
+                return
+            ## Clear chat directory as it has not been completed yet
+            for f in chat_dir_path.iterdir():
+                if f.is_file():
+                    f.unlink()
+
+        ## Get or generate verification program
+        verification_program_path = chat_dir_path / f"{chat_id_name}.py"
+        if not verification_program_path.exists():
+            if "ground_truth_program" in animation_prompt_data:
+                print("\n\nRetrieving verification program")
+                verification_program = animation_prompt_data["ground_truth_program"]
+            else:
+                print("\n\nGenerating verification program")
+                chat_history = [
+                    self.mover_synthesizer.compose_sys_msg(),
+                    self.mover_synthesizer.compose_initial_user_prompt(animation_prompt)
+                ]
+                verification_program, error_msg = self.mover_synthesizer.generate(
+                    chat_history,
+                    str(verification_program_path)
+                )
+                if error_msg:
+                    print(f"Error generating verification program: {error_msg}")
+                    return
+                
+            with open(verification_program_path, "w") as f:
+                f.write(verification_program)
+        else:
+            print("\n\nReading verification program")
+            with open(verification_program_path, "r") as f:
+                verification_program = f.read()
+
+        ## Initialize chat
+        chat_messages = [
+            self.animation_synthesizer.compose_sys_msg(),
+            self.animation_synthesizer.compose_initial_user_prompt(animation_prompt, animation_prompt_data["svg_file_path"])
+        ]
+
+        is_correct = False
+        is_mover_doc_sent = False
+        num_iter = 0
+        server_config = self.config['server']
+        pipeline_config = self.config['pipeline']
+        max_iter = pipeline_config['max_iter']
+
+        ## Run loop until correct or max iterations reached
+        while not is_correct and num_iter < max_iter:
+            print(f"\n\n---------iteration {num_iter}---------")
+            animation_model = self.config['animation_model']
+            print(f"Chat id: {chat_id_name}, Model: {animation_model['name']}, Provider: {animation_model['provider']}\n")
+            
+            ## Generate animation code
+            html_file_name = f"{chat_id_name}_{num_iter}.html"
+            html_file_path = chat_dir_path / html_file_name
+            response, error_msg = self.animation_synthesizer.generate(
+                chat_messages,
+                animation_prompt_data["svg_file_path"],
+                str(html_file_path)
+            )
+
+            ## Update chat history
+            chat_messages.append({"role": "assistant", "content": response})
+            self._save_chat_messages(chat_file_path, chat_messages)
+
+            ## Handle error case
+            if error_msg:
+                print(f"\n\nError extracting code block: {error_msg}")
+                print("Continuing to next iteration with help message.")
+                chat_messages.append({
+                    "role": "user",
+                    "content": "Animation program code is not wrapped in ```javascript and ``` tags. Please wrap it in ```javascript and ``` tags."
+                })
+                self._save_chat_messages(chat_file_path, chat_messages)
+
+                num_iter += 1
+                continue
+
+            ## Convert HTML to animation data
+            animation_data_file = f"{chat_id_name}_{num_iter}_data.json"
+            animation_data_path = chat_dir_path / animation_data_file
+            convert_animation(str(html_file_path), server_config['port'], server_config['create_video'])
+            
+            ## Verify animation
+            try:
+                verification_result = self.verifier.verify(
+                    str(verification_program_path),
+                    str(animation_data_path)
+                )
+            except Exception as e:
+                traceback_str = str(traceback.format_exc())
+                print(f"\n\n{traceback_str}")
+                print("\n\nVerifier errored out. Setting verification result to False.")
+                verification_result = "False: invalid animation."
+                with open(chat_dir_path / f"{chat_id_name}_{num_iter}.out", "w") as f:
+                    f.write(traceback_str)
+            
+            ## Process verification result
+            if "False" in verification_result:
+                is_correct = False
+                
+                ## Build verification message with DSL documentation on first failure
+                verification_message_template = self.verifier.get_correction_msg_template()
+                
+                ## Add DSL documentation only on first verification failure
+                template_params = {
+                    "verification_program": verification_program,
+                    "verification_result": verification_result
+                }
+                
+                if not is_mover_doc_sent:
+                    template_params["dsl_documentation"] = self.mover_synthesizer.get_dsl_documentation()
+                    is_mover_doc_sent = True
+                
+                verification_message = verification_message_template.render(**template_params)
+                
+                chat_messages.append({
+                    "role": "user",
+                    "content": verification_message
+                })
+                self._save_chat_messages(chat_file_path, chat_messages)
+            
+            else:
+                is_correct = True
+                self._write_log(chat_dir_path / "success.log", "succeeded", num_iter)
+            
+            num_iter += 1
+        
+        ## Handle failure case
+        if not is_correct and num_iter >= max_iter:
+            self._write_log(chat_dir_path / "fail.log", "failed", num_iter)
+
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from YAML file.
+    
+    Returns:
+        Dictionary containing pipeline configuration
+        
+    Raises:
+        ValueError: If required fields are missing
+    """
+    parser = argparse.ArgumentParser(description="Run animation pipeline with YAML configuration.")
+    parser.add_argument("config", type=str, help="Path to YAML configuration file")
+    args = parser.parse_args()
+    
+    with open(args.config, 'r') as f:
+        config = yaml.safe_load(f)
+
+    ## Validate required sections
+    required_sections = ['paths', 'server', 'pipeline', 'animation_model', 'mover_model']
+    missing_sections = [s for s in required_sections if s not in config]
+    if missing_sections:
+        raise ValueError(f"Missing required config sections: {', '.join(missing_sections)}")
+    
+    ## Validate paths section
+    paths_config = config['paths']
+    required_paths = ['parent_dir', 'svg_dir', 'animation_prompts_file']
+    missing_paths = [p for p in required_paths if p not in paths_config]
+    if missing_paths:
+        raise ValueError(f"Missing required path configurations: {', '.join(missing_paths)}")
+    
+    ## Validate server section
+    server_config = config['server']
+    required_server = ['port', 'create_video']
+    missing_server = [s for s in required_server if s not in server_config]
+    if missing_server:
+        raise ValueError(f"Missing required server configurations: {', '.join(missing_server)}")
+    
+    ## Validate pipeline section
+    pipeline_config = config['pipeline']
+    if 'max_iter' not in pipeline_config:
+        raise ValueError("Missing required pipeline configuration: max_iter")
+    
+    ## Validate model sections
+    for model_key in ['animation_model', 'mover_model']:
+        model_config = config[model_key]
+        required_model = ['name', 'provider']
+        missing_model = [m for m in required_model if m not in model_config]
+        if missing_model:
+            raise ValueError(f"Missing required {model_key} configurations: {', '.join(missing_model)}")
+    
+    return config
+
+
+def main() -> None:
+    """Main entry point for the animation pipeline."""
+    config = load_config()
+    pipeline = AnimationPipeline(config)
+    
+    paths_config = config['paths']
+    with open(paths_config['animation_prompts_file'], "r") as f:
+        animation_prompts = json.load(f)
+    
+    for animation_prompt_data in animation_prompts:
+        if animation_prompt_data.get("has_run", False):
+            continue
+            
+        print(f"\n\n ---- Running {animation_prompt_data['chat_id_name']} ----\n")
+        try:    
+            pipeline.run_loop(animation_prompt_data)
+            
+        except Exception as e:
+            traceback_str = str(traceback.format_exc())
+            print(f"\n\n{traceback_str}")
+            print("\n\nErrored out. Skipping to next animation prompt.")
+            error_file = Path(paths_config['parent_dir']) / animation_prompt_data["chat_id_name"] / "error.txt"
+            pipeline._write_log(error_file, "errored", 0, traceback_str)
+            continue
+
+
+if __name__ == "__main__":
+    main()

mover/stats.py

@@ -0,0 +1,198 @@
+import os
+import json
+import heapq
+import argparse
+import yaml
+
+parser = argparse.ArgumentParser()
+parser.add_argument("configs", type=str, nargs='+', help="List of YAML config files to process.")
+
+args, unknown = parser.parse_known_args()
+
+## Helper function to extract paths from config
+def get_paths_from_config(config_file):
+    with open(config_file, 'r') as f:
+        config = yaml.safe_load(f)
+    
+    paths_config = config['paths']
+    return (
+        paths_config['parent_dir'],
+        paths_config['animation_prompts_file']
+    )
+
+def format_stats(total_input, chat_dir, error_count, total, num_more_than_one, num_iterations, num_fail, iterations_data=None, is_total=False):
+    """Helper function to format statistics in a consistent format.
+    
+    Args:
+        total_input: Number of total input prompts
+        chat_dir: Name of chat directory (or "Total stats" for totals)
+        error_count: Number of errors
+        total: Total number of prompts processed
+        num_more_than_one: Number of prompts that took more than one attempt
+        num_iterations: Number of prompts that succeeded after multiple attempts
+        num_fail: Number of failed prompts
+        iterations_data: Tuple of (sum_iterations, min_iter, max_iter) for calculating average
+        is_total: Whether this is printing total stats
+        
+    Returns:
+        Formatted string containing the statistics
+    """
+    lines = []
+    if not is_total:
+        lines.extend([
+            f"\n\nTotal input: {total_input}",
+            f"Chat dir:    {os.path.basename(chat_dir)}"
+        ])
+    else:
+        lines.extend([
+            "\n------------",
+            "Total stats\n",
+            f"Total input: {total_input}"
+        ])
+        
+    lines.extend([
+        f"error:       {error_count}",
+        f"Total:       {total}",
+        f"pass@0:      {(total - num_more_than_one)} ({(total - num_more_than_one) / total * 100})",
+        f"pass@1+:     {num_iterations} ({num_iterations / total * 100})",
+        f"fail:        {num_fail} ({num_fail / total * 100})"
+    ])
+    
+    if iterations_data and iterations_data[1] > 0:  # If we have iteration data and at least one multi-attempt success
+        avg_iters = iterations_data[0] / iterations_data[1]
+        lines.append(f"avg. iters.: {avg_iters} ({iterations_data[2]}-{iterations_data[3]})")
+    else:
+        lines.append("avg. iters.: N/A")
+        
+    return "\n".join(lines)
+
+
+def get_stats(parent_dirs, animation_prompts_files, chat_id_prefix=None):
+    total_prompts = []
+    total_input_prompts = []
+    total_num_more_than_one = []
+    total_num_fail = []
+    total_num_iterations = []
+    total_error_count = []
+
+    for parent_dir in parent_dirs:
+        with open(animation_prompts_files[parent_dirs.index(parent_dir)], 'r') as file:
+            chat_prompts = json.load(file)
+        chat_id_names = [chat_prompt["chat_id_name"] for chat_prompt in chat_prompts]
+        total_input_prompts.append(len(chat_prompts))
+        
+        ## for each subdirectory in parent_dir, count the number of html files
+        html_file_count = []
+        for subdir, _, files in os.walk(parent_dir):
+            if subdir == parent_dir:
+                continue
+            
+            error_file = [file for file in files if file == 'error.txt']
+            subdir_name = os.path.basename(subdir)
+            error_count = len(error_file)
+            
+            ## read the json chat_file named the same as the subdir_name and count the number of objects with "role": "assistant"
+            chat_file = os.path.join(parent_dir, subdir_name, f"{subdir_name}.json")
+            num_assistant_messages = 0
+            if os.path.exists(chat_file):
+                with open(chat_file, 'r') as f:
+                    chat_data = json.load(f)
+                    num_assistant_messages = sum(1 for message in chat_data if message.get("role") == "assistant")
+            else:
+                error_count = 1
+                
+            if subdir_name in chat_id_names:
+                html_file_count.append((subdir_name, num_assistant_messages, error_count))
+        
+        ## sort the subdirectories by its name
+        html_file_count = sorted(html_file_count, key=lambda x: x[0].split("_")[2:], reverse=False)
+
+        ## print the html file count in a table format
+        num_more_than_one = 0
+        num_fail = 0
+        count_num_iterations = []
+        num_iterations = 0
+        filtered_html_file_count = []
+        num_error_count = 0
+        for subdir, count, error_count in html_file_count:
+            if chat_id_prefix is not None:
+                if not subdir.startswith(chat_id_prefix):
+                    continue
+            
+            if error_count > 0:
+                num_error_count += 1
+                continue
+            
+            filtered_html_file_count.append((subdir, count, error_count))
+            success_log_file = os.path.join(parent_dir, subdir, "success.log")
+            fail_log_file = os.path.join(parent_dir, subdir, "fail.log")
+            
+            if count > 1:
+                num_more_than_one += 1
+            
+            if os.path.exists(success_log_file):
+                ## prompt took more than one attempt
+                if count > 1:
+                    num_iterations += 1
+                    count_num_iterations.append(count)
+                    
+            elif os.path.exists(fail_log_file):
+                num_fail += 1
+            
+        html_file_count = filtered_html_file_count
+        total_prompts.append(len(html_file_count))
+        total_num_more_than_one.append(num_more_than_one)
+        total_num_fail.append(num_fail)
+        total_num_iterations.append((sum(count_num_iterations), num_iterations, min(count_num_iterations, default=0), heapq.nlargest(1, count_num_iterations)[0] if count_num_iterations else 0))
+        total_error_count.append(num_error_count)
+        
+    output = []
+    for i in range(len(parent_dirs)):
+        stats = format_stats(
+            total_input=total_input_prompts[i],
+            chat_dir=parent_dirs[i],
+            error_count=total_error_count[i],
+            total=total_prompts[i],
+            num_more_than_one=total_num_more_than_one[i],
+            num_iterations=total_num_iterations[i][1],
+            num_fail=total_num_fail[i],
+            iterations_data=total_num_iterations[i]
+        )
+        output.append(stats)
+    
+    # Only show total stats if there is more than one config
+    if len(parent_dirs) > 1:
+        num_total_prompts = sum(total_prompts)
+        num_total_more_than_one = sum(total_num_more_than_one)
+        num_total_50 = sum(total_num_fail)
+        count_num_total_iterations = sum([(x[0]) for x in total_num_iterations])
+        num_total_iterations = sum([x[1] for x in total_num_iterations])
+        min_iterations = min([x[2] for x in total_num_iterations if x[2] > 0], default=0)
+        max_iterations = max([x[3] for x in total_num_iterations], default=0)
+        
+        total_stats = format_stats(
+            total_input=sum(total_input_prompts),
+            chat_dir="Total stats",
+            error_count=sum(total_error_count),
+            total=num_total_prompts,
+            num_more_than_one=num_total_more_than_one,
+            num_iterations=num_total_iterations,
+            num_fail=num_total_50,
+            iterations_data=(count_num_total_iterations, num_total_iterations, min_iterations, max_iterations),
+            is_total=True
+        )
+        output.append(total_stats)
+    
+    return "\n".join(output)
+
+if __name__ == "__main__":
+    ## Extract paths from config files
+    parent_dirs = []
+    animation_prompts_files = []
+    for config_file in args.configs:
+        parent_dir, prompts_file = get_paths_from_config(config_file)
+        parent_dirs.append(parent_dir)
+        animation_prompts_files.append(prompts_file)
+        
+    stats_output = get_stats(parent_dirs, animation_prompts_files)
+    print(stats_output)

mover-0.1.0.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: mover
+Version: 0.1.0
+Summary: Official implementation of MoVer: Motion Verification for Motion Graphics Animations
+Author-email: Jiaju Ma <jiajuma@stanford.edu>
+License: Apache-2.0
+Project-URL: Homepage, https://mover-dsl.github.io/
+Project-URL: Repository, https://github.com/mover-dsl/MoVer
+Project-URL: Bug Tracker, https://github.com/mover-dsl/MoVer/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: cairosvg
+Requires-Dist: fastapi==0.115.14
+Requires-Dist: groq
+Requires-Dist: Jinja2
+Requires-Dist: numpy
+Requires-Dist: openai
+Requires-Dist: opencv-contrib-python==4.11.0.86
+Requires-Dist: Pillow
+Requires-Dist: playwright
+Requires-Dist: protobuf
+Requires-Dist: PyYAML
+Requires-Dist: treelib
+Requires-Dist: uvicorn==0.35.0
+Requires-Dist: torch>=2.7.1
+Requires-Dist: torchvision>=0.22.1
+Requires-Dist: jacinle
+Requires-Dist: concepts
+Requires-Dist: ipykernel>=6.29.5
+Provides-Extra: local
+Requires-Dist: ollama-python; extra == "local"
+Requires-Dist: vllm; extra == "local"
+Dynamic: license-file
+
+# MoVer: Motion Verification for Motion Graphics Animations
+
+[Jiaju Ma](https://majiaju.io) and
+[Maneesh Agrawala](https://graphics.stanford.edu/~maneesh/)
+<br />
+In ACM Transactions on Graphics (SIGGRAPH), 44(4), August 2025. To Appear.
+<br />
+
+[[arXiv](https://arxiv.org/abs/2502.13372)]  [[project page](https://mover-dsl.github.io/)]
+
+
+## Dataset
+The test prompt dataset used in the paper can be found in `mover_dataset`
+
+
+## Setup
+
+### JavaScript animation to MoVer data format converter
+1. (Optional) We support rendering to video with OpenCV, but the video produced might have limited compatibility. If you optionally install `ffmpeg`, our converter will automatically use it to convert rendered videos.
+
+### MoVer
+1. Set up a virtual environment with your favorite tool. It is recommended to use `uv` because it is very fast.
+2. Make sure you have `pytorch` installed
+3. Install [Jacinle](https://github.com/vacancy/Jacinle).
+```bash
+  git clone https://github.com/vacancy/Jacinle --recursive
+  cd Jacinle
+  pip install -e . # or uv pip install -e . or follow the instructions on the Jacinle GitHub page
+```
+
+4. Install [Concepts](https://github.com/concepts-ai/concepts).
+```bash
+  git clone https://github.com/concepts-ai/Concepts.git
+  cd Concepts
+  pip install -e . # or uv pip install -e .
+```
+
+5. Run `pip install -r requirements.txt` or `uv pip install -r requirements.txt` to install the remaining dependencies
+    - This list includes APIs to interface with OpenAI, Gemini (via OpenAI), and Groq
+
+6. Store your API keys as environment variables (e.g., `OPENAI_API_KEY`, `GEMINI_API_KEY`, `GROQ_API_KEY`).
+
+7. If you plan to run locally-hosted models, install the following dependencies:
+    - Install `ollama` if you plan to use ollama with `ollama-python`
+    - Install `vLLM` if you plan to use vLLM
+
+
+## Usage
+Check out the `tutorial.ipynb` for a tutorial of the motion graphics animation generation with MoVer verification pipeline.
+
+
+## Release Checklist
+- [x] MoVer DSL and verifier
+- [x] JavaScript animation to MoVer data format converter
+- [x] LLM-based animation synthesizer
+- [x] LLM-based MoVer synthesizer
+- [x] Scripts to run the full pipeline
+- [ ] Web app for creating animations with MoVer
+- [ ] Scripts for generating animation prompts

mover-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mover/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mover/pipeline.py,sha256=ltwrtfXo0X77uNrncx_P22KLjGuKbH5NIGbeni2EEzM,13282
+mover/stats.py,sha256=EWGkUMqXKGh6ofAbp-IHfMiuXlIfs82bMw6WWCaHURs,7987
+mover-0.1.0.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+mover-0.1.0.dist-info/METADATA,sha256=-JZveij2YeuXial_QCGA69No5tCyBx6WO26YUNKpifg,3720
+mover-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mover-0.1.0.dist-info/top_level.txt,sha256=b4wDkAsfAUdbiUZGLr-SMKNQjSb4eko4vYy-hjQaInE,6
+mover-0.1.0.dist-info/RECORD,,

mover-0.1.0.dist-info/WHEEL

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

mover-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mover-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mover