malwareDetector 0.2.0__py3-none-any.whl

malware_detector/__init__.py

@@ -0,0 +1,37 @@
+"""Malware Detector Framework.
+
+A base framework for building malware detectors with:
+- Pydantic v2 configuration system
+- Typer-based extensible CLI
+- Structured logging with structlog
+- ABC-based detector with customizable pipeline
+
+Source code: https://github.com/louiskyee/malwareDetector.git
+Documentation: https://github.com/louiskyee/malwareDetector/wiki
+PyPI: https://pypi.org/project/malware-detector/
+"""
+
+from importlib.metadata import version
+
+from .cli import create_cli
+from .config import BaseDetectorConfig, FolderConfig, PathConfig
+from .detector import BaseDetector
+from .logging import configure_logging, get_logger
+
+__version__ = version(__package__ or __name__)
+
+__all__ = [
+    # Version
+    "__version__",
+    # Config
+    "BaseDetectorConfig",
+    "PathConfig",
+    "FolderConfig",
+    # Detector
+    "BaseDetector",
+    # CLI
+    "create_cli",
+    # Logging
+    "configure_logging",
+    "get_logger",
+]

malware_detector/cli.py

@@ -0,0 +1,146 @@
+"""CLI factory using Typer for extensible command-line interfaces.
+
+This module provides a factory function to create CLI applications for
+any BaseDetector subclass. The generated CLI includes common commands
+like `run` and `init`, and can be extended with custom commands.
+
+Typical usage:
+    from malware_detector import create_cli
+    from my_detector import MyDetector
+
+    app = create_cli(MyDetector)
+
+    # Add custom commands
+    @app.command()
+    def evaluate():
+        ...
+
+    if __name__ == "__main__":
+        app()
+"""
+
+from pathlib import Path
+from typing import Annotated, Literal
+
+import typer
+
+from .config import BaseDetectorConfig
+from .detector import BaseDetector
+from .logging import configure_logging
+
+
+def config_to_toml(config: BaseDetectorConfig) -> str:
+    """Convert configuration to TOML format string.
+
+    Args:
+        config: Configuration instance to serialize.
+
+    Returns:
+        TOML-formatted configuration string.
+    """
+    lines: list[str] = []
+
+    # Path section
+    lines.append("[path]")
+    for name, value in config.path.model_dump().items():
+        lines.append(f'{name} = "{value}"')
+    lines.append("")
+
+    # Folder section
+    lines.append("[folder]")
+    for name, value in config.folder.model_dump().items():
+        lines.append(f'{name} = "{value}"')
+    lines.append("")
+
+    # Top-level fields
+    lines.append(f"classify = {str(config.classify).lower()}")
+
+    return "\n".join(lines)
+
+
+def create_cli(
+    detector_class: type[BaseDetector],
+    config_class: type[BaseDetectorConfig] | None = None,
+) -> typer.Typer:
+    """Create a CLI application for a detector class.
+
+    This factory function generates a Typer CLI with standard commands
+    for running the detector pipeline and initializing configuration.
+
+    Args:
+        detector_class: The detector class to create CLI for.
+        config_class: Optional configuration class. If None, uses
+            detector_class.config_class.
+
+    Returns:
+        Configured Typer application.
+
+    Example:
+        app = create_cli(MyDetector)
+
+        @app.command()
+        def custom_command():
+            '''Add custom commands to the CLI.'''
+            ...
+
+        if __name__ == "__main__":
+            app()
+    """
+    app = typer.Typer(
+        name=detector_class.__name__,
+        help=detector_class.__doc__ or f"CLI for {detector_class.__name__}",
+    )
+    resolved_config_class = config_class or detector_class.config_class
+
+    @app.callback()
+    def main(
+        log_level: Annotated[
+            str,
+            typer.Option("--log-level", "-l", help="Log level"),
+        ] = "INFO",
+        log_format: Annotated[
+            Literal["console", "json"],
+            typer.Option("--log-format", help="Log format: console or json"),
+        ] = "console",
+    ) -> None:
+        """Configure global options for the CLI."""
+        configure_logging(level=log_level, format=log_format)
+
+    @app.command()
+    def run(
+        config_path: Annotated[
+            Path | None,
+            typer.Option("--config", "-c", help="Config file path"),
+        ] = None,
+        stages: Annotated[
+            str | None,
+            typer.Option("--stages", "-s", help="Comma-separated stages to run"),
+        ] = None,
+    ) -> None:
+        """Run the detector pipeline."""
+        if config_path and config_path.exists():
+            config = resolved_config_class.model_validate_json(
+                config_path.read_text()
+            )
+        else:
+            config = resolved_config_class()
+
+        stage_list = stages.split(",") if stages else None
+
+        detector = detector_class(config)
+        detector.setup()
+        detector.run(stage_list)
+
+    @app.command()
+    def init(
+        output: Annotated[
+            Path,
+            typer.Option("--output", "-o", help="Output config file path"),
+        ] = Path("config.toml"),
+    ) -> None:
+        """Generate default configuration file."""
+        config = resolved_config_class()
+        output.write_text(config_to_toml(config))
+        typer.echo(f"Config written to {output}")
+
+    return app

malware_detector/config.py

@@ -0,0 +1,135 @@
+"""Configuration system using Pydantic v2 and pydantic-settings.
+
+This module provides a hierarchical configuration system that supports:
+- Default values
+- TOML configuration files
+- Environment variables
+- Programmatic overrides
+
+Configuration priority (later overrides earlier):
+    1. Default values (defined in models)
+    2. Config file (config.toml)
+    3. Environment variables (MALWARE_DETECTOR_*)
+    4. Direct assignment
+
+Typical usage:
+    from malware_detector.config import BaseDetectorConfig
+
+    # Load with defaults
+    config = BaseDetectorConfig()
+
+    # Load from file
+    config = BaseDetectorConfig.load(Path("config.toml"))
+
+    # Subclass for custom configs
+    class MyConfig(BaseDetectorConfig):
+        batch_size: int = 32
+"""
+
+from pathlib import Path
+from typing import Self
+
+from pydantic import BaseModel, ConfigDict
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class PathConfig(BaseModel):
+    """Path configuration for input/output files.
+
+    Attributes:
+        input: Path to input dataset directory or file.
+        output: Path to output prediction file.
+        config: Path to configuration file.
+    """
+
+    model_config = ConfigDict(extra="allow")
+
+    input: Path = Path("./Dataset/program")
+    output: Path = Path("./Predict/predict.json")
+    config: Path = Path("./config.toml")
+
+
+class FolderConfig(BaseModel):
+    """Folder configuration for data storage directories.
+
+    Attributes:
+        dataset: Directory for raw dataset files.
+        feature: Directory for extracted features.
+        vectorize: Directory for vectorized data.
+        model: Directory for trained models.
+        predict: Directory for prediction outputs.
+    """
+
+    model_config = ConfigDict(extra="allow")
+
+    dataset: Path = Path("./Dataset/")
+    feature: Path = Path("./Feature/")
+    vectorize: Path = Path("./Vectorize/")
+    model: Path = Path("./Model/")
+    predict: Path = Path("./Predict/")
+
+    @property
+    def all_folders(self) -> list[Path]:
+        """Return all folder paths defined in this config.
+
+        Returns:
+            List of all Path-typed field values.
+        """
+        return [
+            getattr(self, name)
+            for name, field_info in type(self).model_fields.items()
+            if field_info.annotation is Path
+        ]
+
+
+class BaseDetectorConfig(BaseSettings):
+    """Base configuration for malware detectors.
+
+    This class can be subclassed to add detector-specific configuration
+    options. All fields support loading from environment variables with
+    the MALWARE_DETECTOR_ prefix.
+
+    Attributes:
+        path: Path configuration for input/output files.
+        folder: Folder configuration for data directories.
+        classify: Whether to perform family classification (vs detection).
+
+    Example:
+        class MyDetectorConfig(BaseDetectorConfig):
+            model_config = SettingsConfigDict(
+                env_prefix="MY_DETECTOR_",
+                toml_file="my_config.toml",
+            )
+            batch_size: int = 32
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="MALWARE_DETECTOR_",
+        env_nested_delimiter="__",
+        extra="allow",
+    )
+
+    path: PathConfig = PathConfig()
+    folder: FolderConfig = FolderConfig()
+    classify: bool = False
+
+    def save(self, path: Path | None = None) -> None:
+        """Save configuration to a JSON file.
+
+        Args:
+            path: Output file path. Defaults to self.path.config.
+        """
+        save_path = path or self.path.config
+        save_path.write_text(self.model_dump_json(indent=2))
+
+    @classmethod
+    def load(cls, path: Path) -> Self:
+        """Load configuration from a JSON file.
+
+        Args:
+            path: Path to the configuration file.
+
+        Returns:
+            Loaded configuration instance.
+        """
+        return cls.model_validate_json(path.read_text())

malware_detector/detector.py

@@ -0,0 +1,128 @@
+"""Base detector class for malware detection pipelines.
+
+This module provides the base class for all malware detectors.
+Subclasses should implement stage methods matching the names in
+default_stages.
+
+Typical usage:
+    from malware_detector import BaseDetector, BaseDetectorConfig
+
+    class MyDetector(BaseDetector):
+        def stage_extract(self) -> Any:
+            # Extract features from dataset
+            ...
+
+        def stage_vectorize(self) -> Any:
+            # Convert features to vectors
+            ...
+
+        def stage_train(self) -> Any:
+            # Train the model
+            ...
+
+        def stage_predict(self) -> Any:
+            # Run predictions
+            ...
+
+    detector = MyDetector()
+    detector.setup()
+    results = detector.run()
+"""
+
+from typing import Any
+
+import structlog
+
+from .config import BaseDetectorConfig
+
+
+class BaseDetector:
+    """Base class for malware detectors.
+
+    This class defines the interface and common functionality for all
+    malware detectors. Subclasses should implement stage methods matching
+    the names in default_stages (e.g., stage_extract for "extract").
+
+    For standard detectors, implement: stage_extract, stage_vectorize,
+    stage_train, and stage_predict.
+
+    For custom pipelines, override default_stages and implement matching
+    stage methods.
+
+    Attributes:
+        default_stages: List of stage names to run by default.
+        config_class: Configuration class to use for this detector.
+        config: The loaded configuration instance.
+        log: Structured logger bound to this detector.
+
+    Example:
+        class MyDetector(BaseDetector):
+            config_class = MyConfig
+
+            def stage_extract(self) -> Path:
+                self.log.info("extracting_features")
+                # Implementation...
+                return self.config.folder.feature
+
+            def stage_vectorize(self) -> Any:
+                ...
+
+            def stage_train(self) -> Any:
+                ...
+
+            def stage_predict(self) -> Any:
+                ...
+    """
+
+    default_stages: list[str] = ["extract", "vectorize", "train", "predict"]
+    config_class: type[BaseDetectorConfig] = BaseDetectorConfig
+
+    def __init__(self, config: BaseDetectorConfig | None = None) -> None:
+        """Initialize the detector with configuration.
+
+        Args:
+            config: Configuration instance. If None, creates default config
+                using config_class.
+        """
+        self.config = config or self.config_class()
+        self.log = structlog.get_logger().bind(
+            detector=self.__class__.__name__,
+        )
+
+    def setup(self) -> None:
+        """Create all required directories from folder configuration."""
+        for folder in self.config.folder.all_folders:
+            folder.mkdir(parents=True, exist_ok=True)
+            self.log.debug("folder_created", path=str(folder))
+
+    def run(self, stages: list[str] | None = None) -> dict[str, Any]:
+        """Execute the detection pipeline.
+
+        Args:
+            stages: List of stage names to run. If None, runs all
+                default_stages.
+
+        Returns:
+            Dictionary mapping stage names to their return values.
+
+        Raises:
+            NotImplementedError: If a requested stage method doesn't exist.
+        """
+        stages = stages or self.default_stages
+        results: dict[str, Any] = {}
+
+        self.log.info("pipeline_started", stages=stages)
+
+        for stage in stages:
+            method = getattr(self, f"stage_{stage}", None)
+            if method is None:
+                self.log.error("stage_not_found", stage=stage)
+                raise NotImplementedError(f"Stage '{stage}' not implemented")
+
+            self.log.info("stage_started", stage=stage)
+            result = method()
+            results[stage] = result
+            self.log.info("stage_completed", stage=stage)
+
+        self.log.info("pipeline_completed", stages=stages)
+        return results

malware_detector/logging.py

@@ -0,0 +1,85 @@
+"""Structured logging configuration using structlog.
+
+This module provides a unified logging interface with support for both
+console (human-readable) and JSON (machine-readable) output formats.
+
+Typical usage:
+    from malware_detector.logging import configure_logging, get_logger
+
+    configure_logging(level="INFO", format="console")
+    log = get_logger(__name__)
+    log.info("event_name", key="value")
+"""
+
+import logging
+import sys
+from typing import Literal
+
+import structlog
+from structlog.types import Processor
+
+# Map string level names to logging module constants
+_LOG_LEVELS: dict[str, int] = {
+    "DEBUG": logging.DEBUG,
+    "INFO": logging.INFO,
+    "WARNING": logging.WARNING,
+    "ERROR": logging.ERROR,
+    "CRITICAL": logging.CRITICAL,
+}
+
+
+def configure_logging(
+    level: str = "INFO",
+    format: Literal["console", "json"] = "console",
+) -> None:
+    """Configure structlog for the application.
+
+    This function should be called once at application startup to configure
+    the logging format and level.
+
+    Args:
+        level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL).
+        format: Output format - "console" for human-readable, "json" for
+            machine-readable structured logs.
+    """
+    log_level = _LOG_LEVELS.get(level.upper(), logging.INFO)
+
+    shared_processors: list[Processor] = [
+        structlog.contextvars.merge_contextvars,
+        structlog.processors.add_log_level,
+        structlog.processors.TimeStamper(fmt="iso"),
+    ]
+
+    if format == "json":
+        processors: list[Processor] = [
+            *shared_processors,
+            structlog.processors.JSONRenderer(),
+        ]
+    else:
+        processors = [
+            *shared_processors,
+            structlog.dev.ConsoleRenderer(colors=sys.stdout.isatty()),
+        ]
+
+    structlog.configure(
+        processors=processors,
+        wrapper_class=structlog.make_filtering_bound_logger(log_level),
+        context_class=dict,
+        logger_factory=structlog.PrintLoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+
+def get_logger(name: str | None = None) -> structlog.typing.FilteringBoundLogger:
+    """Get a logger instance.
+
+    Args:
+        name: Optional module name to bind to the logger.
+
+    Returns:
+        A configured structlog BoundLogger instance.
+    """
+    logger: structlog.typing.FilteringBoundLogger = structlog.get_logger()
+    if name:
+        return logger.bind(module=name)
+    return logger

malwaredetector-0.2.0.dist-info/METADATA

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: malwareDetector
+Version: 0.2.0
+Summary: Base framework for building malware detectors
+Project-URL: Homepage, https://github.com/louiskyee/malwareDetector
+Project-URL: Documentation, https://github.com/louiskyee/malwareDetector/wiki
+Project-URL: Repository, https://github.com/louiskyee/malwareDetector.git
+Author-email: PO-LIN LAI <bolin8017@gmail.com>
+License: MIT
+License-File: LICENCE.txt
+Keywords: detector,framework,malware,security
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: pydantic-settings<3.0,>=2.0
+Requires-Dist: pydantic<3.0,>=2.0
+Requires-Dist: structlog<25.0,>=24.0
+Requires-Dist: typer<1.0,>=0.9
+Provides-Extra: dev
+Requires-Dist: mypy<2.0,>=1.8; extra == 'dev'
+Requires-Dist: pytest-cov<5.0,>=4.0; extra == 'dev'
+Requires-Dist: pytest<9.0,>=8.0; extra == 'dev'
+Requires-Dist: ruff<1.0,>=0.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# malware-detector
+
+A base framework for building malware detectors with modern Python.
+
+* Source code: https://github.com/louiskyee/malwareDetector.git
+* Wiki: https://github.com/louiskyee/malwareDetector/wiki
+* PyPI: https://pypi.org/project/malware-detector/
+
+## Features
+
+- **Pydantic v2 Configuration** - Type-safe config with env vars and file support
+- **Typer CLI** - Extensible command-line interface via factory function
+- **Structured Logging** - Console and JSON output formats with structlog
+- **Customizable Pipeline** - Define your own stages or use defaults
+- **Type Hints** - Full typing support with py.typed marker
+
+## Requirements
+
+| Tool | Version |
+|------|---------|
+| Python | >= 3.12 |
+
+## Installation
+
+```bash
+pip install malware-detector
+```
+
+Or with [uv](https://github.com/astral-sh/uv):
+
+```bash
+uv add malware-detector
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from malware_detector import BaseDetector, BaseDetectorConfig
+
+class MyDetector(BaseDetector):
+    """My custom malware detector."""
+
+    def stage_extract(self):
+        self.log.info("extracting_features", input=str(self.config.path.input))
+        # Extract features from dataset
+        return self.config.folder.feature
+
+    def stage_vectorize(self):
+        # Convert features to vectors
+        return self.config.folder.vectorize
+
+    def stage_train(self):
+        # Train the model
+        return self.config.folder.model
+
+    def stage_predict(self):
+        # Run predictions
+        return self.config.path.output
+
+
+# Run the detector
+detector = MyDetector()
+detector.setup()  # Creates directories
+results = detector.run()  # Runs all stages
+```
+
+### Run Specific Stages
+
+```python
+# Run only extract and vectorize
+results = detector.run(stages=["extract", "vectorize"])
+```
+
+### Custom Pipeline
+
+```python
+class ClusteringDetector(BaseDetector):
+    """Detector with custom pipeline stages."""
+
+    default_stages = ["preprocess", "embed", "cluster", "export"]
+
+    def stage_preprocess(self):
+        ...
+
+    def stage_embed(self):
+        ...
+
+    def stage_cluster(self):
+        ...
+
+    def stage_export(self):
+        ...
+```
+
+## Configuration
+
+### Custom Config
+
+```python
+from pydantic_settings import SettingsConfigDict
+from malware_detector import BaseDetectorConfig
+
+class MyConfig(BaseDetectorConfig):
+    """Custom configuration with additional fields."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="MY_DETECTOR_",
+    )
+
+    batch_size: int = 32
+    model_name: str = "default"
+    use_gpu: bool = True
+
+
+class MyDetector(BaseDetector):
+    config_class = MyConfig
+
+    def stage_train(self):
+        self.log.info("training", batch_size=self.config.batch_size)
+        ...
+```
+
+### Environment Variables
+
+```bash
+export MALWARE_DETECTOR_CLASSIFY=true
+export MALWARE_DETECTOR_PATH__INPUT="./my_dataset"
+```
+
+### Config File
+
+Save as `config.toml`:
+
+```toml
+[path]
+input = "./Dataset/program"
+output = "./Predict/predict.json"
+
+[folder]
+dataset = "./Dataset/"
+feature = "./Feature/"
+
+classify = false
+```
+
+## CLI Integration
+
+### Create CLI for Your Detector
+
+```python
+from malware_detector import create_cli
+from my_detector import MyDetector
+
+app = create_cli(MyDetector)
+
+# Add custom commands
+@app.command()
+def evaluate():
+    """Evaluate the trained model."""
+    ...
+
+if __name__ == "__main__":
+    app()
+```
+
+### CLI Usage
+
+```bash
+# Generate default config
+python -m my_detector init --output config.toml
+
+# Run full pipeline
+python -m my_detector run --config config.toml
+
+# Run specific stages
+python -m my_detector run --stages extract,vectorize
+
+# JSON logging for production
+python -m my_detector run --log-format json --log-level DEBUG
+```
+
+## Logging
+
+```python
+from malware_detector import configure_logging, get_logger
+
+# Configure at startup
+configure_logging(level="INFO", format="console")
+
+# Get a logger
+log = get_logger(__name__)
+log.info("event_name", key="value", count=42)
+```
+
+Output formats:
+
+```bash
+# Console (development)
+2024-01-19T10:30:00 [info] event_name    key=value count=42
+
+# JSON (production)
+{"event": "event_name", "key": "value", "count": 42, "timestamp": "..."}
+```
+
+## Migration from v0.1.x
+
+| v0.1.x | v0.2.0 |
+|--------|--------|
+| `from malwareDetector.detector import detector` | `from malware_detector import BaseDetector` |
+| `class MyDetector(detector)` | `class MyDetector(BaseDetector)` |
+| `def extractFeature(self)` | `def stage_extract(self)` |
+| `def vectorize(self)` | `def stage_vectorize(self)` |
+| `def model(self, training)` | `def stage_train(self)` |
+| `def predict(self)` | `def stage_predict(self)` |
+| `config.json()` | `config.model_dump_json()` |
+| `Config.parse_raw(data)` | `Config.model_validate_json(data)` |
+
+## License
+
+MIT

malwaredetector-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+malware_detector/__init__.py,sha256=TONSYdjbFUHghYdF0fvO__uDPfVJCgLykf1eH6Qs_M8,928
+malware_detector/cli.py,sha256=5u4OnxflAQhzNO6Mhtq0Czehjl4GqP7WM5Ya2YgclX0,4114
+malware_detector/config.py,sha256=NSCZo7HHfk-n7i2FUapTCTPwNySy0NnWyrzRmTa0rkc,3902
+malware_detector/detector.py,sha256=veFgO8cvUAJBAOIo3WXNov1BoA5sEdxk3VrAPMIxo1o,3992
+malware_detector/logging.py,sha256=gIhlYou81gadWwfzSCcppGRbI0bMwPJJ0QlJR8cQ_yk,2455
+malware_detector/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+malwaredetector-0.2.0.dist-info/METADATA,sha256=NBChOTvhLVW2UzhYK8bOORvZU4-a22CUHOjjZWuS-s4,5904
+malwaredetector-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+malwaredetector-0.2.0.dist-info/licenses/LICENCE.txt,sha256=mtPx5Z9lQ9ASzCLcwbit290IQIfmRQqstebUtzSzAvc,1068
+malwaredetector-0.2.0.dist-info/RECORD,,

malwaredetector-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

malwaredetector-0.2.0.dist-info/licenses/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 (PO-LIN LAI)
+
+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.