unifi-network-maps 1.4.11__py3-none-any.whl

unifi_network_maps/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.4.11"

unifi_network_maps/__main__.py

@@ -0,0 +1,8 @@
+"""Module entrypoint for python -m unifi_network_maps."""
+
+from __future__ import annotations
+
+from .cli.main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

unifi_network_maps/adapters/__init__.py

@@ -0,0 +1 @@
+"""Package module."""

unifi_network_maps/adapters/config.py

@@ -0,0 +1,49 @@
+"""Configuration loading from environment variables."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+
+def _parse_bool(value: str | None, default: bool = True) -> bool:
+    if value is None:
+        return default
+    normalized = value.strip().lower()
+    if normalized in {"1", "true", "yes", "y", "on"}:
+        return True
+    if normalized in {"0", "false", "no", "n", "off"}:
+        return False
+    return default
+
+
+@dataclass(frozen=True)
+class Config:
+    url: str
+    site: str
+    user: str
+    password: str
+    verify_ssl: bool
+
+    @classmethod
+    def from_env(cls, *, env_file: str | None = None) -> Config:
+        if env_file:
+            try:
+                from dotenv import load_dotenv
+            except ImportError:
+                raise ValueError("python-dotenv required for --env-file") from None
+            load_dotenv(dotenv_path=env_file)
+        url = os.environ.get("UNIFI_URL", "").strip()
+        site = os.environ.get("UNIFI_SITE", "default").strip()
+        user = os.environ.get("UNIFI_USER", "").strip()
+        password = os.environ.get("UNIFI_PASS", "").strip()
+        verify_ssl = _parse_bool(os.environ.get("UNIFI_VERIFY_SSL"), default=True)
+
+        if not url:
+            raise ValueError("UNIFI_URL is required")
+        if not user:
+            raise ValueError("UNIFI_USER is required")
+        if not password:
+            raise ValueError("UNIFI_PASS is required")
+
+        return cls(url=url, site=site, user=user, password=password, verify_ssl=verify_ssl)

unifi_network_maps/adapters/unifi.py

@@ -0,0 +1,457 @@
+"""UniFi API integration."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+import stat
+import time
+from collections.abc import Callable, Iterator, Sequence
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import TimeoutError as FutureTimeoutError
+from contextlib import contextmanager
+from pathlib import Path
+from typing import IO, TYPE_CHECKING
+
+from .config import Config
+
+if TYPE_CHECKING:
+    from unifi_controller_api import UnifiController
+
+logger = logging.getLogger(__name__)
+
+
+def _cache_dir() -> Path:
+    return Path(os.environ.get("UNIFI_CACHE_DIR", ".cache/unifi_network_maps"))
+
+
+def _device_attr(device: object, name: str) -> object | None:
+    if isinstance(device, dict):
+        return device.get(name)
+    return getattr(device, name, None)
+
+
+def _first_attr(device: object, *names: str) -> object | None:
+    for name in names:
+        value = _device_attr(device, name)
+        if value is not None:
+            return value
+    return None
+
+
+def _as_list(value: object | None) -> list[object]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    if isinstance(value, dict):
+        return [value]
+    if isinstance(value, str | bytes):
+        return []
+    try:
+        return list(value)  # type: ignore[arg-type]
+    except TypeError:
+        return []
+
+
+def _serialize_lldp_entry(entry: object) -> dict[str, object]:
+    return {
+        "chassis_id": _first_attr(entry, "chassis_id", "chassisId"),
+        "port_id": _first_attr(entry, "port_id", "portId"),
+        "port_desc": _first_attr(entry, "port_desc", "portDesc", "port_descr", "portDescr"),
+        "local_port_name": _first_attr(entry, "local_port_name", "localPortName"),
+        "local_port_idx": _first_attr(entry, "local_port_idx", "localPortIdx"),
+    }
+
+
+def _serialize_lldp_entries(value: object | None) -> list[dict[str, object]]:
+    entries = _as_list(value)
+    serialized: list[dict[str, object]] = []
+    for entry in entries:
+        data = _serialize_lldp_entry(entry)
+        if data.get("chassis_id") and data.get("port_id"):
+            serialized.append(data)
+    return serialized
+
+
+def _serialize_port_entry(entry: object) -> dict[str, object]:
+    aggregation_group = _first_attr(
+        entry,
+        "aggregation_group",
+        "aggregation_id",
+        "aggregate_id",
+        "agg_id",
+        "lag_id",
+        "lag_group",
+        "link_aggregation_group",
+        "link_aggregation_id",
+        "aggregate",
+        "aggregated_by",
+    )
+    return {
+        "port_idx": _first_attr(entry, "port_idx", "portIdx"),
+        "name": _first_attr(entry, "name"),
+        "ifname": _first_attr(entry, "ifname"),
+        "speed": _first_attr(entry, "speed"),
+        "aggregation_group": aggregation_group,
+        "port_poe": _first_attr(entry, "port_poe"),
+        "poe_enable": _first_attr(entry, "poe_enable"),
+        "poe_good": _first_attr(entry, "poe_good"),
+        "poe_power": _first_attr(entry, "poe_power"),
+    }
+
+
+def _serialize_port_table(value: object | None) -> list[dict[str, object]]:
+    return [_serialize_port_entry(entry) for entry in _as_list(value)]
+
+
+def _serialize_uplink(value: object | None) -> dict[str, object] | None:
+    if value is None:
+        return None
+    data = {
+        "uplink_mac": _first_attr(value, "uplink_mac", "uplink_device_mac"),
+        "uplink_device_name": _first_attr(value, "uplink_device_name", "uplink_name"),
+        "uplink_remote_port": _first_attr(value, "uplink_remote_port", "port_idx"),
+    }
+    if any(item is not None for item in data.values()):
+        return data
+    return None
+
+
+def _device_lldp_value(device: object) -> object | None:
+    lldp_info = _device_attr(device, "lldp_info")
+    if lldp_info is None:
+        lldp_info = _device_attr(device, "lldp")
+    if lldp_info is None:
+        lldp_info = _device_attr(device, "lldp_table")
+    return lldp_info
+
+
+def _device_uplink_fields(device: object) -> dict[str, object | None]:
+    return {
+        "uplink": _serialize_uplink(_device_attr(device, "uplink")),
+        "last_uplink": _serialize_uplink(_device_attr(device, "last_uplink")),
+        "uplink_mac": _first_attr(device, "uplink_mac", "uplink_device_mac"),
+        "uplink_device_name": _device_attr(device, "uplink_device_name"),
+        "uplink_remote_port": _device_attr(device, "uplink_remote_port"),
+        "last_uplink_mac": _device_attr(device, "last_uplink_mac"),
+    }
+
+
+def _serialize_device_for_cache(device: object) -> dict[str, object]:
+    payload = {
+        "name": _device_attr(device, "name"),
+        "model_name": _device_attr(device, "model_name"),
+        "model": _device_attr(device, "model"),
+        "mac": _device_attr(device, "mac"),
+        "ip": _first_attr(device, "ip", "ip_address"),
+        "type": _first_attr(device, "type", "device_type"),
+        "displayable_version": _first_attr(device, "displayable_version", "version"),
+        "lldp_info": _serialize_lldp_entries(_device_lldp_value(device)),
+        "port_table": _serialize_port_table(_device_attr(device, "port_table")),
+    }
+    payload.update(_device_uplink_fields(device))
+    return payload
+
+
+def _serialize_devices_for_cache(devices: Sequence[object]) -> list[dict[str, object]]:
+    return [_serialize_device_for_cache(device) for device in devices]
+
+
+def _cache_lock_path(path: Path) -> Path:
+    return path.with_suffix(path.suffix + ".lock")
+
+
+def _acquire_cache_lock(lock_file: IO[str]) -> None:
+    if os.name == "nt":
+        import msvcrt
+
+        msvcrt.locking(lock_file.fileno(), msvcrt.LK_LOCK, 1)
+    else:
+        import fcntl
+
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+
+
+def _release_cache_lock(lock_file: IO[str]) -> None:
+    if os.name == "nt":
+        import msvcrt
+
+        msvcrt.locking(lock_file.fileno(), msvcrt.LK_UNLCK, 1)
+    else:
+        import fcntl
+
+        fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+
+
+@contextmanager
+def _cache_lock(path: Path) -> Iterator[None]:
+    lock_path = _cache_lock_path(path)
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open("a+", encoding="utf-8") as lock_file:
+        try:
+            _acquire_cache_lock(lock_file)
+            yield
+        finally:
+            try:
+                _release_cache_lock(lock_file)
+            except OSError:
+                logger.debug("Failed to release cache lock %s", lock_path)
+
+
+def _is_cache_dir_safe(path: Path) -> bool:
+    if not path.exists():
+        return True
+    try:
+        mode = stat.S_IMODE(path.stat().st_mode)
+    except OSError as exc:
+        logger.warning("Failed to stat cache dir %s: %s", path, exc)
+        return False
+    if mode & (stat.S_IWGRP | stat.S_IWOTH):
+        logger.warning("Cache dir %s is group/world-writable; skipping cache", path)
+        return False
+    return True
+
+
+def _cache_ttl_seconds() -> int:
+    value = os.environ.get("UNIFI_CACHE_TTL_SECONDS", "").strip()
+    if not value:
+        return 3600
+    if value.isdigit():
+        return int(value)
+    logger.warning("Invalid UNIFI_CACHE_TTL_SECONDS value: %s", value)
+    return 3600
+
+
+def _cache_key(*parts: str) -> str:
+    digest = hashlib.sha256("|".join(parts).encode("utf-8")).hexdigest()
+    return digest[:24]
+
+
+def _load_cache(path: Path, ttl_seconds: int) -> Sequence[object] | None:
+    data, age = _load_cache_with_age(path)
+    if data is None:
+        return None
+    if ttl_seconds <= 0:
+        return None
+    if age is None or age > ttl_seconds:
+        return None
+    return data
+
+
+def _load_cache_with_age(path: Path) -> tuple[Sequence[object] | None, float | None]:
+    if not path.exists():
+        return None, None
+    try:
+        with _cache_lock(path):
+            payload = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        logger.debug("Failed to read cache %s: %s", path, exc)
+        return None, None
+    if not isinstance(payload, dict):
+        logger.debug("Cached payload at %s is not a dict", path)
+        return None, None
+    timestamp = payload.get("timestamp")
+    if not isinstance(timestamp, int | float):
+        return None, None
+    data = payload.get("data")
+    if not isinstance(data, list):
+        logger.debug("Cached payload at %s is not a list", path)
+        return None, None
+    return data, time.time() - timestamp
+
+
+def _save_cache(path: Path, data: Sequence[object]) -> None:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        if not _is_cache_dir_safe(path.parent):
+            return
+        payload = {"timestamp": time.time(), "data": data}
+        tmp_path = path.with_suffix(path.suffix + ".tmp")
+        with _cache_lock(path):
+            tmp_path.write_text(json.dumps(payload, ensure_ascii=True), encoding="utf-8")
+            tmp_path.replace(path)
+    except Exception as exc:
+        logger.debug("Failed to write cache %s: %s", path, exc)
+
+
+def _retry_attempts() -> int:
+    value = os.environ.get("UNIFI_RETRY_ATTEMPTS", "").strip()
+    if not value:
+        return 2
+    if value.isdigit():
+        return max(1, int(value))
+    logger.warning("Invalid UNIFI_RETRY_ATTEMPTS value: %s", value)
+    return 2
+
+
+def _retry_backoff_seconds() -> float:
+    value = os.environ.get("UNIFI_RETRY_BACKOFF_SECONDS", "").strip()
+    if not value:
+        return 0.5
+    try:
+        return max(0.0, float(value))
+    except ValueError:
+        logger.warning("Invalid UNIFI_RETRY_BACKOFF_SECONDS value: %s", value)
+        return 0.5
+
+
+def _request_timeout_seconds() -> float | None:
+    value = os.environ.get("UNIFI_REQUEST_TIMEOUT_SECONDS", "").strip()
+    if not value:
+        return None
+    try:
+        return max(0.0, float(value))
+    except ValueError:
+        logger.warning("Invalid UNIFI_REQUEST_TIMEOUT_SECONDS value: %s", value)
+        return None
+
+
+def _call_with_timeout[T](operation: str, func: Callable[[], T], timeout: float | None) -> T:
+    if timeout is None or timeout <= 0:
+        return func()
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        future = executor.submit(func)
+        try:
+            return future.result(timeout=timeout)
+        except FutureTimeoutError as exc:
+            future.cancel()
+            raise TimeoutError(f"{operation} timed out after {timeout:.2f}s") from exc
+
+
+def _call_with_retries[T](operation: str, func: Callable[[], T]) -> T:
+    attempts = _retry_attempts()
+    backoff = _retry_backoff_seconds()
+    timeout = _request_timeout_seconds()
+    last_exc: Exception | None = None
+    for attempt in range(1, attempts + 1):
+        try:
+            return _call_with_timeout(operation, func, timeout)
+        except Exception as exc:  # noqa: BLE001 - surface full error after retries
+            last_exc = exc
+            logger.warning("Failed %s attempt %d/%d: %s", operation, attempt, attempts, exc)
+            if attempt < attempts and backoff > 0:
+                time.sleep(backoff * attempt)
+    if last_exc:
+        raise last_exc
+    raise RuntimeError(f"Failed {operation}")
+
+
+def _init_controller(config: Config, *, is_udm_pro: bool) -> UnifiController:
+    from unifi_controller_api import UnifiController
+
+    return UnifiController(
+        controller_url=config.url,
+        username=config.user,
+        password=config.password,
+        is_udm_pro=is_udm_pro,
+        verify_ssl=config.verify_ssl,
+    )
+
+
+def fetch_devices(
+    config: Config,
+    *,
+    site: str | None = None,
+    detailed: bool = True,
+    use_cache: bool = True,
+) -> Sequence[object]:
+    """Fetch devices from UniFi Controller.
+
+    Uses `unifi-controller-api` to authenticate and return device objects.
+    """
+    try:
+        from unifi_controller_api import UnifiAuthenticationError
+    except ImportError as exc:
+        raise RuntimeError("Missing dependency: unifi-controller-api") from exc
+
+    site_name = site or config.site
+    ttl_seconds = _cache_ttl_seconds()
+    cache_path = _cache_dir() / f"devices_{_cache_key(config.url, site_name, str(detailed))}.json"
+    if use_cache and _is_cache_dir_safe(cache_path.parent):
+        cached = _load_cache(cache_path, ttl_seconds)
+        stale_cached, cache_age = _load_cache_with_age(cache_path)
+    else:
+        cached = None
+        stale_cached, cache_age = None, None
+    if cached is not None:
+        logger.info("Using cached devices (%d)", len(cached))
+        return cached
+
+    try:
+        controller = _init_controller(config, is_udm_pro=True)
+    except UnifiAuthenticationError:
+        logger.info("UDM Pro authentication failed, retrying legacy auth")
+        controller = _init_controller(config, is_udm_pro=False)
+
+    def _fetch() -> Sequence[object]:
+        return controller.get_unifi_site_device(site_name=site_name, detailed=detailed, raw=False)
+
+    try:
+        devices = _call_with_retries("device fetch", _fetch)
+    except Exception as exc:  # noqa: BLE001 - fallback to cache
+        if stale_cached is not None:
+            logger.warning(
+                "Device fetch failed; using stale cache (%ds old): %s",
+                int(cache_age or 0),
+                exc,
+            )
+            return stale_cached
+        raise
+    if use_cache:
+        _save_cache(cache_path, _serialize_devices_for_cache(devices))
+    logger.info("Fetched %d devices", len(devices))
+    return devices
+
+
+def fetch_clients(
+    config: Config,
+    *,
+    site: str | None = None,
+    use_cache: bool = True,
+) -> Sequence[object]:
+    """Fetch active clients from UniFi Controller."""
+    try:
+        from unifi_controller_api import UnifiAuthenticationError
+    except ImportError as exc:
+        raise RuntimeError("Missing dependency: unifi-controller-api") from exc
+
+    site_name = site or config.site
+    ttl_seconds = _cache_ttl_seconds()
+    cache_path = _cache_dir() / f"clients_{_cache_key(config.url, site_name)}.json"
+    if use_cache and _is_cache_dir_safe(cache_path.parent):
+        cached = _load_cache(cache_path, ttl_seconds)
+        stale_cached, cache_age = _load_cache_with_age(cache_path)
+    else:
+        cached = None
+        stale_cached, cache_age = None, None
+    if cached is not None:
+        logger.info("Using cached clients (%d)", len(cached))
+        return cached
+
+    try:
+        controller = _init_controller(config, is_udm_pro=True)
+    except UnifiAuthenticationError:
+        logger.info("UDM Pro authentication failed, retrying legacy auth")
+        controller = _init_controller(config, is_udm_pro=False)
+
+    def _fetch() -> Sequence[object]:
+        return controller.get_unifi_site_client(site_name=site_name, raw=True)
+
+    try:
+        clients = _call_with_retries("client fetch", _fetch)
+    except Exception as exc:  # noqa: BLE001 - fallback to cache
+        if stale_cached is not None:
+            logger.warning(
+                "Client fetch failed; using stale cache (%ds old): %s",
+                int(cache_age or 0),
+                exc,
+            )
+            return stale_cached
+        raise
+    if use_cache:
+        _save_cache(cache_path, clients)
+    logger.info("Fetched %d clients", len(clients))
+    return clients

unifi_network_maps/assets/icons/access-point.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" id="mdi-access-point" viewBox="0 0 24 24"><path d="M4.93,4.93C3.12,6.74 2,9.24 2,12C2,14.76 3.12,17.26 4.93,19.07L6.34,17.66C4.89,16.22 4,14.22 4,12C4,9.79 4.89,7.78 6.34,6.34L4.93,4.93M19.07,4.93L17.66,6.34C19.11,7.78 20,9.79 20,12C20,14.22 19.11,16.22 17.66,17.66L19.07,19.07C20.88,17.26 22,14.76 22,12C22,9.24 20.88,6.74 19.07,4.93M7.76,7.76C6.67,8.85 6,10.35 6,12C6,13.65 6.67,15.15 7.76,16.24L9.17,14.83C8.45,14.11 8,13.11 8,12C8,10.89 8.45,9.89 9.17,9.17L7.76,7.76M16.24,7.76L14.83,9.17C15.55,9.89 16,10.89 16,12C16,13.11 15.55,14.11 14.83,14.83L16.24,16.24C17.33,15.15 18,13.65 18,12C18,10.35 17.33,8.85 16.24,7.76M12,10A2,2 0 0,0 10,12A2,2 0 0,0 12,14A2,2 0 0,0 14,12A2,2 0 0,0 12,10Z" /></svg>

unifi_network_maps/assets/icons/isometric/ISOPACKS_LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 Mark Mankarious
+
+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.

unifi_network_maps/assets/icons/isometric/block.svg

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="551.59998px" height="343.79999px" viewBox="0 0 551.59998 343.79999"
+	 style="enable-background:new 0 0 551.59998 343.79999;" xml:space="preserve">
+<style type="text/css">
+	.st0{opacity:0.4;enable-background:new    ;}
+	.st1{fill:#CDD9EE;}
+	.st2{fill:#B5C5DC;}
+	.st3{fill:#FFFFFF;}
+	.st4{fill:#6885A9;}
+	.st5{fill:#231F20;}
+</style>
+<g>
+	<polygon class="st0" points="309.29999,322.89999 274.60001,316.10001 274,16.2 551.59998,180 	"/>
+	<polygon class="st1" points="274.60001,228.8 92.2,119.2 274,9.7 457,119.2 	"/>
+	<polygon class="st2" points="90.2,195 274.60001,305.79999 274.60001,305.79999 274.60001,231.3 90.2,120.4 	"/>
+	<polygon class="st3" points="288.29999,220.60001 135.7,127.7 303,27 274,9.7 92.2,119.2 274.60001,228.8 	"/>
+	<polygon class="st4" points="459,195 274.60001,305.79999 274.60001,305.79999 274.60001,231.3 459,120.4 	"/>
+	<path class="st5" d="M467.20001,115.6L467.20001,115.6L274,0L83.00002,115.1l-1,0.6v83.7l192.59998,115.80002L466.20001,200
+		l1-0.60001V115.6z M274,9.7l183,109.5L274.60001,228.8L92.20001,119.2L274,9.7z M457,124.1v69.69999L276.70001,302.20001V232.5
+		L457,124.1z M272.60001,232.39999v69.69998L92.30001,193.8v-69.7L272.60001,232.39999z"/>
+</g>
+</svg>

unifi_network_maps/assets/icons/isometric/cache.svg

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 25.3.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="55.1px" height="57.3px" viewBox="0 0 55.1 57.3" enable-background="new 0 0 55.1 57.3" xml:space="preserve">
+<g id="Layer_3">
+</g>
+<g id="Layer_4">
+</g>
+<g id="Layer_10">
+	<g opacity="0.4" fill="#000000">
+		<polygon points="35.6,46 38.3,48.1 25.6,52.1 21.2,53 32,38.9 41.4,44.8 		"/>
+	</g>
+</g>
+<g id="Layer_7">
+</g>
+<g id="Layer_6">
+	<polygon fill="#F2C256" points="31.6,19 18.4,11.1 18.4,33.9 21.2,35.5 21.2,52.1 31.6,31.5 26,28.1 	"/>
+	<polygon fill="#FFE4AE" points="18.4,33.9 18.5,33.9 25.6,15.4 18.4,11.1 	"/>
+	<polygon fill="none" stroke="#010202" stroke-width="0.5" stroke-linejoin="round" stroke-miterlimit="10" points="31.6,19 
+		18.4,11.1 18.4,33.9 21.2,35.5 21.2,52.1 31.6,31.5 26,28.1 	"/>
+</g>
+<g id="Layer_5">
+	<polygon fill="#F7C56B" stroke="#010202" stroke-width="0.4" stroke-linejoin="round" stroke-miterlimit="10" points="18.4,11.1 
+		24.5,7.4 37.6,15.3 32,24.3 37.6,27.7 27.2,48.3 21.2,52.1 31.6,31.5 26,28.1 31.6,19 	"/>
+	<polygon fill="#754F0C" stroke="#010202" stroke-width="0.4" stroke-miterlimit="10" points="37.6,15.3 31.6,19 26,28.1 31.6,31.5 
+		21.2,52.1 27.2,48.3 37.6,27.7 32,24.3 	"/>
+	<g id="Layer_12">
+	</g>
+	<polygon fill="none" stroke="#010202" stroke-width="0.4" stroke-linejoin="round" stroke-miterlimit="10" points="18.4,11.1 
+		24.5,7.4 37.6,15.3 32,24.3 37.6,27.7 27.2,48.3 21.2,52.1 31.6,31.5 26,28.1 31.6,19 	"/>
+</g>
+<g id="Layer_8">
+	<polygon fill="#AF7A2E" stroke="#010202" stroke-width="0.4" stroke-linejoin="round" stroke-miterlimit="10" points="31.6,31.5 
+		37.6,27.7 32,24.3 26,28.1 	"/>
+</g>
+<g id="Layer_11">
+	<polyline fill="none" stroke="#010202" stroke-width="0.4" stroke-linejoin="round" stroke-miterlimit="10" points="37.6,15.3 
+		31.6,19 26,28.1 32,24.3 37.6,15.3 	"/>
+</g>
+<g id="Layer_9">
+	<g>
+		<path fill="#010202" d="M24.5,7.4l13.2,7.9l-5.7,9l5.6,3.4L27.2,48.3l-6,3.7V35.5l-2.7-1.6V11.1L24.5,7.4 M24.5,6.6
+			c-0.1,0-0.3,0-0.4,0.1l-6,3.7c-0.2,0.1-0.4,0.4-0.4,0.7v22.8c0,0.3,0.1,0.5,0.4,0.7l2.3,1.4v16.1c0,0.3,0.2,0.6,0.4,0.7
+			c0.1,0.1,0.3,0.1,0.4,0.1s0.3,0,0.4-0.1l6-3.7c0.1-0.1,0.2-0.2,0.3-0.3l10.4-20.6c0.2-0.4,0.1-0.8-0.3-1l-4.9-3l5.2-8.4
+			c0.1-0.2,0.1-0.4,0.1-0.6c-0.1-0.2-0.2-0.4-0.4-0.5l-13.1-8C24.7,6.6,24.6,6.6,24.5,6.6L24.5,6.6z"/>
+	</g>
+</g>
+</svg>