Resource API¶

def get_resources() -> Dict[str, Any]

from wfrmls import WFRMLSClient

client = WFRMLSClient()

# Get all available resources
resources = client.resource.get_resources()

# List resource names
for resource in resources["value"]:
    name = resource.get("RName")
    path = resource.get("ResourcePath")
    print(f"{name}: {path}")

def get_resource_by_name(
    resource_name: str
) -> Dict[str, Any]

# Get details about the Property resource
property_resource = client.resource.get_resource_by_name("Property")

# Get details about the Member resource
member_resource = client.resource.get_resource_by_name("Member")

def explore_api_structure():
    """Dynamically explore available API endpoints."""

    # Get all resources
    resources = client.resource.get_resources()

    api_structure = {
        "base_url": client.base_url,
        "resources": {},
        "total_resources": len(resources["value"])
    }

    # Build resource map
    for resource in resources["value"]:
        name = resource.get("RName")
        api_structure["resources"][name] = {
            "path": resource.get("ResourcePath"),
            "description": resource.get("Description"),
            "last_modified": resource.get("TimestampModified")
        }

    return api_structure

# Explore API
api_map = explore_api_structure()
print(f"Found {api_map['total_resources']} resources")

def validate_endpoint_exists(endpoint_name: str) -> bool:
    """Check if an endpoint exists in the API."""

    resources = client.resource.get_resources()

    valid_endpoints = set()
    for resource in resources["value"]:
        name = resource.get("RName", "").lower()
        valid_endpoints.add(name)

    return endpoint_name.lower() in valid_endpoints

# Validate endpoints
print(validate_endpoint_exists("Property"))  # True
print(validate_endpoint_exists("InvalidEndpoint"))  # False

def generate_api_docs():
    """Generate documentation for available endpoints."""

    resources = client.resource.get_resources()

    docs = []
    docs.append("# WFRMLS API Endpoints\n")
    docs.append("## Available Resources\n")

    for resource in sorted(resources["value"], key=lambda x: x.get("RName", "")):
        name = resource.get("RName")
        path = resource.get("ResourcePath")
        desc = resource.get("Description")
        modified = resource.get("TimestampModified")

        docs.append(f"\n### {name}")
        docs.append(f"- **Endpoint**: `{path}`")
        docs.append(f"- **Description**: {desc}")
        docs.append(f"- **Last Modified**: {modified}")
        docs.append("")

    return "\n".join(docs)

# Generate documentation
api_docs = generate_api_docs()

from datetime import datetime

def check_resource_updates():
    """Check for updates to API resources."""

    current_resources = client.resource.get_resources()

    # In a real application, you'd compare with stored data
    updates = {
        "check_time": datetime.now().isoformat(),
        "resources": {}
    }

    for resource in current_resources["value"]:
        name = resource.get("RName")
        modified = resource.get("TimestampModified")

        updates["resources"][name] = {
            "available": True,
            "last_modified": modified,
            "path": resource.get("ResourcePath")
        }

    return updates

# Check for updates
resource_status = check_resource_updates()

def configure_client_from_resources():
    """Configure API client based on available resources."""

    resources = client.resource.get_resources()

    config = {
        "endpoints": {},
        "timezone_offset": None
    }

    for resource in resources["value"]:
        name = resource.get("RName")
        path = resource.get("ResourcePath")

        # Store endpoint configuration
        config["endpoints"][name.lower()] = {
            "path": path,
            "full_url": f"{client.base_url}{path}"
        }

        # Get timezone (should be consistent)
        if config["timezone_offset"] is None:
            config["timezone_offset"] = resource.get("TimeZoneOffset")

    return config

# Get client configuration
client_config = configure_client_from_resources()

def build_dynamic_client():
    """Build client methods based on available resources."""

    resources = client.resource.get_resources()

    class DynamicClient:
        def __init__(self, base_client):
            self.client = base_client
            self._endpoints = {}

            # Build endpoint map
            for resource in resources["value"]:
                name = resource.get("RName", "").lower()
                self._endpoints[name] = resource.get("ResourcePath")

        def get_endpoint_data(self, endpoint_name: str, **kwargs):
            """Generic method to get data from any endpoint."""

            if endpoint_name.lower() not in self._endpoints:
                raise ValueError(f"Unknown endpoint: {endpoint_name}")

            # Use the appropriate client method
            if hasattr(self.client, endpoint_name.lower()):
                endpoint_client = getattr(self.client, endpoint_name.lower())
                if hasattr(endpoint_client, f"get_{endpoint_name.lower()}s"):
                    method = getattr(endpoint_client, f"get_{endpoint_name.lower()}s")
                    return method(**kwargs)

            return None

    return DynamicClient(client)

# Create dynamic client
dynamic = build_dynamic_client()