### Setup Virtual Environment and Install Steam

Source: https://github.com/valvepython/steam/blob/master/recipes/README.rst

Demonstrates how to create a virtual environment using virtualenv, activate it, and install the steam package using pip.

```bash
$ virtualenv env
$ source env/bin/activate
(env)$ pip install steam
```

```bash
(env)$ deactivate
```

--------------------------------

### Install Steam Python Module

Source: https://github.com/valvepython/steam/blob/master/docs/intro.rst

Provides instructions for installing the steam Python module from PyPI and GitHub. Includes options for installing with or without SteamClient dependencies and for installing specific development versions.

```bash
# Install latest version from PYPI
# with SteamClient dependencies
pip install -U steam[client]

# without (only when using parts that do no rely on gevent, and protobufs)
pip install -U steam

# Install the current dev version from github
# cutting edge from master
pip install git+https://github.com/ValvePython/steam#egg=steam

# specific version tag (e.g. v1.0.0)
pip install git+https://github.com/ValvePython/steam@v1.0.0#egg=steam[client]
# without SteamClient extras
pip install git+https://github.com/ValvePython/steam@v1.0.0#egg=steam
```

--------------------------------

### Vagrant Development Environment Setup

Source: https://github.com/valvepython/steam/blob/master/README.rst

Sets up a Vagrant virtual machine for development and experimentation. Assumes Vagrant and VirtualBox are installed. The VM is Ubuntu 16.04 with necessary packages and Python virtual environments.

```bash
vagrant up
vagrant ssh
# for python2
$ source venv2/bin/activate
# for python3
$ source venv3/bin/activate
```

--------------------------------

### Install Flask

Source: https://github.com/valvepython/steam/blob/master/recipes/2.SimpleWebAPI/README.rst

Installs the Flask library, a micro web framework for Python, which is a dependency for building the Web API.

```bash
(env)$ pip install flask
```

--------------------------------

### Custom Prompt One-Off Steam Login

Source: https://github.com/valvepython/steam/blob/master/recipes/1.Login/README.rst

This script demonstrates logging into Steam by creating custom prompts for user input, rather than relying on the default `cli_login()` function. It's similar to the minimal example but offers more control over the login process.

```Python
import logging
from valve.steamid import SteamID
from steam.client import SteamClient

logging.basicConfig(level=logging.INFO)

client = SteamClient()

async def run():
    username = input('Username: ')
    password = input('Password: ')
    await client.login(username, password)
    print(f'Logged in as: {client.user.name} ({client.user.id64})')
    await client.logout()

client.run_forever(target=run())

```

--------------------------------

### Install Steam Module via Pip

Source: https://github.com/valvepython/steam/blob/master/README.rst

Installs the latest release version of the steam module from PyPI. The `[client]` extra installs dependencies required for SteamClient.

```bash
pip install -U "steam[client]"
pip install -U steam
```

--------------------------------

### Install Steam Module from GitHub

Source: https://github.com/valvepython/steam/blob/master/README.rst

Installs the steam module directly from the GitHub repository. Supports installing the latest commit from master or a specific version tag.

```bash
pip install "git+https://github.com/ValvePython/steam#egg=steam"
pip install "git+https://github.com/ValvePython/steam@v1.0.0#egg=steam[client]"
pip install "git+https://github.com/ValvePython/steam@v1.0.0#egg=steam"
```

--------------------------------

### Steam WebAPI Initialization and Basic Calls

Source: https://github.com/valvepython/steam/blob/master/docs/user_guide.rst

Demonstrates how to initialize the `WebAPI` class with an API key and make calls to Steam WebAPI endpoints. Includes examples of calling methods directly via interface attributes and using the generic `call` method.

```python
from steam.webapi import WebAPI

api = WebAPI(key="<your api key>")
api.ISteamWebAPIUtil.GetServerInfo()
api.call('ISteamWebAPIUtil.GetServerInfo')
api.ISteamUser.ResolveVanityURL(vanityurl="valve", url_type=2)
api.call('ISteamUser.ResolveVanityURL', vanityurl="valve", url_type=2)
api.ISteamUser.ResolveVanityURL_v1(vanityurl="valve", url_type=2)
api.call('ISteamUser.ResolveVanityURL_v1', vanityurl="valve", url_type=2)
```

--------------------------------

### Install Steam Python Library (Windows - Cygwin)

Source: https://github.com/valvepython/steam/blob/master/docs/install.rst

Installs the Steam Python library on Windows using Cygwin. This involves installing Cygwin, selecting specific Python packages during setup, installing pip, and then installing the library.

```bash
easy_install-3.4 pip
pip install steam
```

--------------------------------

### Get Product Information

Source: https://github.com/valvepython/steam/blob/master/recipes/2.SimpleWebAPI/README.rst

Fetches detailed information for specified application IDs (appids) from the Steam Web API. This example retrieves data for appids 570 and 730.

```curl
$ curl -s 127.0.0.1:5000/ISteamApps/GetProductInfo/?appids=570,730 | head -56
```

```json
{
  "apps": [
    {
      "appid": 570,
      "appinfo": {
        "appid": "570",
        "common": {
          "clienticon": "c0d15684e6c186289b50dfe083f5c562c57e8fb6",
          "clienttga": "5ca2b133f8fdf56c3d81dd73d1254f95f0614265",
          "community_hub_visible": "1",
          "controllervr": {
            "steamvr": "1"
          },
          "exfgls": "1",
          "gameid": "570",
          "header_image": {
            "english": "header.jpg"
          },
          "icon": "0bbb630d63262dd66d2fdd0f7d37e8661a410075",
          "linuxclienticon": "e1c520b6a98b1fed674a117e9356cdb9ddc6d40c",
          "logo": "d4f836839254be08d8e9dd333ecc9a01782c26d2",
          "logo_small": "d4f836839254be08d8e9dd333ecc9a01782c26d2_thumb",
          "metacritic_fullurl": "http://www.metacritic.com/game/pc/dota-2?ftag=MCD-06-10aaa1f",
          "metacritic_name": "Dota 2",
          "metacritic_score": "90"
        }
      }
    }
  ]
}
```

--------------------------------

### Persistent Steam Login with Sentry File

Source: https://github.com/valvepython/steam/blob/master/recipes/1.Login/README.rst

This example shows how to maintain a persistent connection to Steam. The client attempts to automatically reconnect if the network connection is lost or Steam services become unavailable. A sentry file is saved to disk for each account to facilitate faster logins.

```Python
import logging
import asyncio
from valve.steamid import SteamID
from steam.client import SteamClient

logging.basicConfig(level=logging.INFO)

client = SteamClient()

async def run():
    await client.login('YOUR_USERNAME', 'YOUR_PASSWORD', 'sentry_file.bin')
    print(f'Logged in as: {client.user.name} ({client.user.id64})')

    # Keep the client running until interrupted
    while True:
        await asyncio.sleep(1)

client.run_forever(target=run())

```

--------------------------------

### Install Steam Python Library (Linux)

Source: https://github.com/valvepython/steam/blob/master/docs/install.rst

Installs the Steam Python library on Linux systems. Assumes Python and pip are already installed. It's recommended to use a virtual environment.

```bash
pip install steam
```

--------------------------------

### Run Web API Application

Source: https://github.com/valvepython/steam/blob/master/recipes/2.SimpleWebAPI/README.rst

Executes the Python script 'run_webapi.py' to start the HTTP server and the Steam worker. This command initiates the Web API service.

```bash
(env)$ python run_webapi.py
```

--------------------------------

### Install Steam Python Library (Windows - Native Python)

Source: https://github.com/valvepython/steam/blob/master/docs/install.rst

Installs the Steam Python library on Windows using a native Python installation. Requires Python 3.5 or later and installation via pip from the command prompt.

```bash
pip install steam
```

--------------------------------

### One-Off Steam Login

Source: https://github.com/valvepython/steam/blob/master/recipes/1.Login/README.rst

A minimal Python script to log into Steam, retrieve basic account information, and then exit. This script does not persist any login data to disk.

```Python
import logging
from valve.steamid import SteamID
from steam.client import SteamClient

logging.basicConfig(level=logging.INFO)

client = SteamClient()

async def run():
    await client.login('YOUR_USERNAME', 'YOUR_PASSWORD')
    print(f'Logged in as: {client.user.name} ({client.user.id64})')
    await client.logout()

client.run_forever(target=run())

```

--------------------------------

### SteamID Conversion and Representation

Source: https://github.com/valvepython/steam/blob/master/docs/user_guide.rst

Demonstrates converting between different SteamID formats (account ID, Steam2, Steam3, Steam64) and accessing their properties. Includes examples of creating SteamID objects from various inputs and converting them back to different string formats or integers.

```python
from steam.steamid import SteamID

SteamID()
SteamID(12345)
SteamID('12345')
SteamID('STEAM_1:1:6172')
SteamID(103582791429521412)
SteamID('103582791429521412')
SteamID('[g:1:4]')
group = SteamID('[g:1:4]')
group.id
group.as_32
group.as_64
int(group)
str(group)
group.as_steam2
group.as_steam3
group.community_url
```

--------------------------------

### Get Product Changes

Source: https://github.com/valvepython/steam/blob/master/recipes/2.SimpleWebAPI/README.rst

Retrieves a list of application changes since a specified change number. This endpoint is useful for tracking updates to Steam products.

```curl
$ curl -s 127.0.0.1:5000/ISteamApps/GetProductChanges/?since_changenumber=2397700 | head -10
```

```json
{
  "app_changes": [
    {
      "appid": 730,
      "change_number": 2409212
    },
    {
      "appid": 740,
      "change_number": 2409198
    }
  ]
}
```

--------------------------------

### Get Player Count

Source: https://github.com/valvepython/steam/blob/master/recipes/2.SimpleWebAPI/README.rst

Fetches the current number of players online for a given application ID. An appid of 0 typically represents all games.

```curl
curl 127.0.0.1:5000/ISteamApps/GetPlayerCount/?appid=0
```

```json
{
  "eresult": 1,
  "player_count": 2727080
}
```

--------------------------------

### steam.utils.binary Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.utils.rst

Documentation for the steam.utils.binary submodule. Lists members, undocumented members, and inheritance.

```python
.. automodule:: steam.utils.binary
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### steam.utils.proto Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.utils.rst

Documentation for the steam.utils.proto submodule. Lists members, undocumented members, and inheritance.

```python
.. automodule:: steam.utils.proto
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### steam.utils.web Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.utils.rst

Documentation for the steam.utils.web submodule. Lists members, undocumented members, and inheritance.

```python
.. automodule:: steam.utils.web
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### steam.client.gc Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.gc.rst

Provides documentation for the steam.client.gc module, detailing its members and inheritance hierarchy. This module is part of the valvepython/steam project and likely relates to the Game Coordinator functionality.

```python
import steam.client.gc

# The following is a representation of the documentation structure
# Actual code would involve interacting with GC functionalities

# Example of a potential class or function within the module (hypothetical)
class GameCoordinator:
    def __init__(self):
        """Initializes the Game Coordinator client."""
        pass

    def send_message(self, message_type, payload):
        """Sends a message to the Game Coordinator.

        Args:
            message_type (int): The type of the message.
            payload (bytes): The message payload.
        """
        pass

    def receive_message(self):
        """Receives a message from the Game Coordinator.

        Returns:
            tuple: A tuple containing message type and payload.
        """
        pass

# The ':members:' directive implies that all public members (classes, functions, variables)
# of the steam.client.gc module are documented here.
# The ':show-inheritance:' directive indicates that inheritance relationships for classes
# within this module will also be displayed.
```

--------------------------------

### CLI Login and User Information

Source: https://github.com/valvepython/steam/blob/master/docs/user_guide.rst

Demonstrates how to log in to Steam using the CLI, retrieve user details, and handle VAC ban status updates.

```python
from steam.client import SteamClient
from steam.enums.emsg import EMsg

client = SteamClient()

@client.on(EMsg.VACBanStatus)
def print_vac_status(msg):
    print("Number of VAC Bans: %s" % msg.body.numBans)

client.cli_login()

print("Logged on as: %s" % client.user.name)
print("Community profile: %s" % client.steam_id.community_url)
print("Last logon: %s" % client.user.last_logon)
print("Last logoff: %s" % client.user.last_logoff)
print("Number of friends: %d" % len(client.friends))

client.logout()
```

--------------------------------

### steam.utils.appcache Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.utils.rst

Documentation for the steam.utils.appcache submodule. Lists members, undocumented members, and inheritance.

```python
.. automodule:: steam.utils.appcache
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam WebAPI Method and Interface Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/user_guide.rst

Illustrates how to access documentation for Steam WebAPI methods and interfaces. Shows how to retrieve the docstring for a specific method or the documentation for an entire interface or the whole API.

```python
api.ISteamUser.ResolveVanityURL.__doc__
api.ISteamUser.ResolveVanityURL.doc()
api.ISteamUser.doc()
api.doc()
```

--------------------------------

### steam.utils Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.utils.rst

Documentation for the main steam.utils module. Lists members, undocumented members, and inheritance.

```python
.. automodule:: steam.utils
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam Core Module Overview

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.core.rst

This section documents the steam.core module, which contains fundamental components for interacting with the Steam network. It lists all public members, undocumented members, and shows inheritance hierarchies.

```python
.. automodule:: steam.core
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### steam.utils.throttle Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.utils.rst

Documentation for the steam.utils.throttle submodule. Lists members, undocumented members, and inheritance.

```python
.. automodule:: steam.utils.throttle
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Local Testing with Make

Source: https://github.com/valvepython/steam/blob/master/README.rst

Runs the test suite for the steam module. Can be run with the current Python environment or a specific version after setting up a virtual environment.

```bash
make test

virtualenv -p python3 py3
source py3/bin/active
pip install -r requirements.txt
make test
```

--------------------------------

### SteamClient Class Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.rst

Documentation for the SteamClient class, detailing its members, inheritance, and related modules. This class is central to interacting with the Steam network from a client perspective.

```Python
.. automodule:: steam.client
    :members: SteamClient
    :member-order: alphabetical
    :undoc-members:
    :inherited-members:
    :show-inheritance:

.. toctree::
    steam.client.builtins
    steam.client.cdn
    steam.client.gc
    steam.client.user
```

--------------------------------

### Steam Core Submodules

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.core.rst

This section outlines the submodules within steam.core, providing links to detailed documentation for each. These include client messages, connection management, cryptography, manifest processing, and message handling.

```python
.. toctree::

    steam.core.cm
    steam.core.connection
    steam.core.crypto
    steam.core.manifest
    steam.core.msg
```

--------------------------------

### Sending Protobuf Message and Handling Response

Source: https://github.com/valvepython/steam/blob/master/docs/user_guide.rst

Shows how to send a Protobuf message (e.g., friend request) and wait for a specific response, checking the result.

```python
from steam.enums import EResult
from steam.core.msg import MsgProto
from steam.enums.emsg import EMsg

message = MsgProto(EMsg.ClientAddFriend)
message.body.steamid_to_add = 76561197960265728

resp = client.send_message_and_wait(message, EMsg.ClientAddFriendResponse)

if resp.eresult == EResult.OK:
    print("Send a friend request to %s (%d)" % (repr(resp.body.persona_name_added), resp.body.steam_id_added))
else:
    print("Error: %s" % EResult(resp.eresult))
```

--------------------------------

### Enabling Debug Logging

Source: https://github.com/valvepython/steam/blob/master/docs/user_guide.rst

Provides instructions on how to enable debug logging to the console using Python's logging module and how to set verbose debug mode for SteamClient.

```python
import logging
logging.basicConfig(format='[%(asctime)s] %(levelname)s %(name)s: %(message)s', level=logging.DEBUG)
```

```python
client = SteamClient()
client.verbose_debug = True
```

```python
client1 = SteamClient()
client2 = SteamClient()

client1._LOG = logging.getLogger("SC#1")
client2._LOG = logging.getLogger("SC#2")
```

--------------------------------

### Steam API Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/index.rst

Documentation for the Steam API, covering various functionalities and endpoints.

```APIDOC
api/steam
```

--------------------------------

### Registering Response Callbacks

Source: https://github.com/valvepython/steam/blob/master/docs/user_guide.rst

Illustrates how to register callbacks for specific message responses, either directly or by referencing a function.

```python
@client.on(EMsg.ClientAddFriendResponse)
def handle_add_response(msg):
    pass
# OR
client.on(EMsg.ClientAddFriendResponse, handle_add_response)
```

--------------------------------

### steam.core.manifest Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.core.manifest.rst

This section provides detailed documentation for the steam.core.manifest module. It includes information on all public members, undocumented members, and the inheritance hierarchy of the classes within the module.

```python
.. automodule:: steam.core.manifest
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Web Authentication with get_web_session

Source: https://github.com/valvepython/steam/blob/master/docs/user_guide.rst

Demonstrates how to obtain a requests.Session object for web authentication with Steam websites using the SteamClient.

```python
session = client.get_web_session()  # returns requests.Session
session.get('https://store.steampowered.com')
```

--------------------------------

### steam.monkey Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.monkey.rst

Provides documentation for the steam.monkey module, including its members and inheritance. This is generated using Sphinx's automodule directive.

```Python
.. automodule:: steam.monkey
    :members:
    :show-inheritance:
```

--------------------------------

### Steam API Reference Modules

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.rst

This section lists the core modules available in the valvepython library for interacting with the Steam platform. Each module provides specific functionalities for different aspects of Steam integration.

```APIDOC
.. toctree::
    :maxdepth: 10

    steam.client
    steam.core
    steam.enums
    steam.exceptions
    steam.game_servers
    steam.globalid
    steam.guard
    steam.monkey
    steam.steamid
    steam.webapi
    steam.webauth
    steam.utils
```

--------------------------------

### steam.client.user Module Members and Inheritance

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.user.rst

This section details the members and inheritance of the steam.client.user module. It lists all public attributes and methods, along with their documentation, and indicates any base classes or mixins used.

```APIDOC
.. automodule:: steam.client.user
    :members:
    :show-inheritance:
```

--------------------------------

### Steam Proto Enums

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.enums.rst

Documentation for protocol buffer related enumerations in the steam library. It covers all members, undocumented members, and inherited members.

```python
import steam.enums.proto

# Accessing Proto enums
# Example: steam.enums.proto.EProto.k_EProto.k_EProto
```

--------------------------------

### steam.game_servers Module Documentation

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.game_servers.rst

This entry details the members, undocumented members, and inheritance of the steam.game_servers module. It's generated using Sphinx's automodule directive.

```python
.. automodule:: steam.game_servers
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam Client Wallet Login and Balance

Source: https://github.com/valvepython/steam/blob/master/recipes/3.WalletBalance/README.rst

Prompts for Steam Guard codes and displays the user's wallet balance using the Steam client. It does not include error handling for potential issues like Steam service outages.

```Python
import wallet_steamclient

# Example usage (assuming wallet_steamclient.py contains the necessary functions)
# This is a conceptual example as the actual implementation is not provided.
# wallet_steamclient.prompt_login_and_show_balance()
```

--------------------------------

### Steam Web Wallet Balance Retrieval

Source: https://github.com/valvepython/steam/blob/master/recipes/3.WalletBalance/README.rst

Logs into the Steam website, fetches a specific page, and extracts the wallet balance from the HTML source. Includes basic handling for code prompts but lacks robust error management for incorrect inputs or website changes.

```Python
import wallet_webauth

# Example usage (assuming wallet_webauth.py contains the necessary functions)
# This is a conceptual example as the actual implementation is not provided.
# wallet_webauth.login_and_get_balance(username, password, two_factor_code)
```

--------------------------------

### Steam Core Enums

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.enums.rst

Documentation for the main steam.enums module, encompassing all its members, undocumented members, and inherited members.

```python
import steam.enums

# Accessing core enums
# Example: steam.enums.Result.k_EResultOK
```

--------------------------------

### Resolving Community URLs to SteamID

Source: https://github.com/valvepython/steam/blob/master/docs/user_guide.rst

Shows how to resolve Steam community profile URLs into SteamID objects or Steam64 IDs. It covers using the `SteamID.from_url` method and the `steam.steamid.from_url` and `steam.steamid.steam64_from_url` functions.

```python
from steam.steamid import SteamID
import steam.steamid

SteamID.from_url('https://steamcommunity.com/id/drunkenf00l')
steam.steamid.from_url('https://steamcommunity.com/id/drunkenf00l')
steam.steamid.steam64_from_url('http://steamcommunity.com/profiles/76561197968459473')
```

--------------------------------

### Steam WebAuth Module Members

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.webauth.rst

This section details the members of the steam.webauth module, including undocumented members and inheritance information. It is generated using Sphinx's automodule directive.

```Python
.. automodule:: steam.webauth
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam Apps Module

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.builtins.rst

Provides functionalities related to Steam applications. This module includes methods for retrieving information about games and applications available on Steam.

```python
.. automodule:: steam.client.builtins.apps
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam Game Servers Module

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.builtins.rst

Enables management and querying of Steam game servers. This module offers functionalities for server browsing and status checks.

```python
.. automodule:: steam.client.builtins.gameservers
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam Common Enums

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.enums.rst

Documentation for common enumerations used in the steam library. This includes members, undocumented members, and inherited members.

```python
import steam.enums.common

# Accessing common enums
# Example: steam.enums.common.EMsg.k_EMsgClientLogOn
```

--------------------------------

### Steam Leaderboards Module

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.builtins.rst

Provides access to Steam's leaderboard system. This module allows developers to integrate and manage leaderboards for their games.

```python
.. automodule:: steam.client.builtins.leaderboards
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam Web Module

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.builtins.rst

Facilitates interactions with Steam's web API. This module contains methods for making requests to various Steam web services.

```python
.. automodule:: steam.client.builtins.web
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam EMSG Enums

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.enums.rst

Documentation for EMSG (External Message) enumerations within the steam library. This section details all members, including undocumented and inherited ones.

```python
import steam.enums.emsg

# Accessing EMSG enums
# Example: steam.enums.emsg.EMsg.k_EMsgClientHello
```

--------------------------------

### Steam User Module

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.builtins.rst

Handles user-specific data and operations within the Steam client. This module allows access to user profiles, inventory, and other personal information.

```python
.. automodule:: steam.client.builtins.user
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### SteamID Class and Conversion Functions

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.steamid.rst

This section details the SteamID class and associated functions for parsing and converting Steam IDs. It covers methods for creating SteamID objects from URLs and converting between different Steam ID representations (steam2, steam3).

```python
steam.steamid
    :members: SteamID, from_url, steam64_from_url, steam2_to_tuple, steam3_to_tuple
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam Unified Messages Module

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.builtins.rst

Manages unified messaging functionalities on Steam. This module is used for sending and receiving messages across different Steam platforms.

```python
.. automodule:: steam.client.builtins.unified_messages
    :members:
    :undoc-members:
    :show-inheritance:
```

--------------------------------

### Steam Friends Module

Source: https://github.com/valvepython/steam/blob/master/docs/api/steam.client.builtins.rst

Handles friend-related functionalities within the Steam client. This module allows for managing friend lists, statuses, and interactions.

```python
.. automodule:: steam.client.builtins.friends
    :members:
    :undoc-members:
    :show-inheritance:
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.