from typing import Dict, Tuple, Sequence

ConnectionOptions = Dict[str, str]
Address = Tuple[str, int]
Server = Tuple[Address, ConnectionOptions]

def broadcast_message(message: str, servers: Sequence[Server]) -> None:
    ...

# The static type checker will treat the previous type signature as
# being exactly equivalent to this one.
def broadcast_message(
        message: str,
        servers: Sequence[Tuple[Tuple[str, int], Dict[str, str]]]) -> None:
    ...

class ExampleError(Exception):
    """예외는 클래스와 같은 방식으로 문서화됩니다

    __init__ 메소드는 클래스 수준 혹은 __init__ 메소드 자체의
    docstring으로 문서화 할 수 있습니다.

    두가지 형태의 docstring은 모두 허용되지만, 혼합해서 사용해선 안됩니다.
    일관성을 유지하려면 한가지만 사용 부탁드립니다.

    Either form is acceptable, but the two should not be mixed. Choose one
    convention to document the __init__ method and be consistent with it.

    Note:
        Args 섹션에 `self`변수를 포함하지 않습니다.

    Args:
        msg (str): 예외를 설명하는 사람이 읽을 수 있는 문자열.
        code (:obj:`int`, optional): 에러 코드.

    Attributes:
        msg (str): 예외를 설명하는 사람이 읽을 수 있는 문자열.
        code (int): 에러 코드.

    """

    def __init__(self, msg: str, code: int) -> None:
        self.msg = msg
        self.code = code

def example_method(self, param1: int, param2: int) -> bool:
        """클래스 메소드는 일반적인 함수와 비슷합니다.

        Note:
            Args 섹션에 `self`변수를 포함하지 않습니다.

        Args:
            param1 (int): 첫번째 파라미터
            param2 (int): 두번째 파라미터

        Returns:
            (bool) 성공적이라면 True, 성공이 아니라면 False

        Example:
        >>> r = np.array([1, 1, 1])
        >>> discount_rewards(r, 0.99)
        np.array([1 + 0.99 + 0.99**2, 1 + 0.99, 1])
        """

        return True

def square_10():
    return 10 * 10

import pytest

from pytest_sample import square_10


def test_square():
    f1 = square_10()
    assert f1 == 100

class LitClassifier(pl.LightningModule):

    def __init__(self):
        super().__init__()
        self.l1 = torch.nn.Linear(28 * 28, 10)

    def forward(self, x):
        return torch.relu(self.l1(x.view(x.size(0), -1)))

    def training_step(self, batch, batch_nb):
        x, y = batch
        loss = F.cross_entropy(self(x), y)
        tensorboard_logs = {'train_loss': loss}
        return {'loss': loss, 'log': tensorboard_logs}

    def configure_optimizers(self):
        return torch.optim.Adam(self.parameters(), lr=0.02)

# train!
train_loader = DataLoader(MNIST(os.getcwd(), train=True, download=True, transform=transforms.ToTensor()), batch_size=32)

model = LitClassifier()
trainer = pl.Trainer(gpus=8, precision=16)    
trainer.fit(model, train_loader)

import wandb
# Your custom arguments defined here
args = ...

wandb.init(config=args, project="my-project")
wandb.config["more"] = "custom"

def training_loop():
    while True:
        # Do some machine learning
        epoch, loss, val_loss = ...
        # Framework agnostic / custom metrics
        wandb.log({"epoch": epoch, "loss": loss, "val_loss": val_loss})

import torch.optim as optim
from ray import tune
from ray.tune.examples.mnist_pytorch import get_data_loaders, ConvNet, train, test


def train_mnist(config):
    train_loader, test_loader = get_data_loaders()
    model = ConvNet()
    optimizer = optim.SGD(model.parameters(), lr=config["lr"])
    for i in range(10):
        train(model, optimizer, train_loader)
        acc = test(model, test_loader)
        tune.report(mean_accuracy=acc)


analysis = tune.run(
    train_mnist, config={"lr": tune.grid_search([0.001, 0.01, 0.1])})

print("Best config: ", analysis.get_best_config(metric="mean_accuracy"))

# Get a dataframe for analyzing trial results.
df = analysis.dataframe()