# Before
server.send_notification("my/customNotification", {"example": "data"})

# After
server.protocol.notify("my/customNotification", {"example": "data"})

@server.command("codeLens.evaluateSum")
def evaluate_sum(ls: LanguageServer, args):
    logging.info("arguments: %s", args)  # here args is a list of dict
    arguments = args[0]
    document = ls.workspace.get_text_document(arguments["uri"])
    line = document.lines[arguments["line"]]

    # Compute the edit that will update the document with the result.
    answer = arguments["left"] + arguments["right"]
    edit = types.TextDocumentEdit(
        text_document=types.OptionalVersionedTextDocumentIdentifier(
            uri=arguments["uri"],
            version=document.version,
        ),
        edits=[
            types.TextEdit(
                new_text=f"{line.strip()} {answer}\n",
                range=types.Range(
                    start=types.Position(line=arguments["line"], character=0),
                    end=types.Position(line=arguments["line"] + 1, character=0),
                ),
            )
        ],
    )

    # Apply the edit.
    ls.workspace_apply_edit(
        types.ApplyWorkspaceEditParams(
            edit=types.WorkspaceEdit(document_changes=[edit]),
        ),
    )

@attrs.define
class EvaluateSumArgs:
    """Represents the arguments to pass to the ``codeLens.evaluateSum`` command"""
    uri: str
    """The uri of the document to edit"""
    left: int
    """The left argument to ``+``"""
    right: int
    """The right argument to ``+``"""
    line: int
    """The line number to edit"""

@server.command("codeLens.evaluateSum")
def evaluate_sum(ls: LanguageServer, args: EvaluateSumArgs):
    logging.info("arguments: %s", args)  # here args is an instance of EvaluateSumArgs
    document = ls.workspace.get_text_document(args.uri)
    line = document.lines[args.line]

    # Compute the edit that will update the document with the result.
    answer = args.left + args.right
    edit = types.TextDocumentEdit(
        text_document=types.OptionalVersionedTextDocumentIdentifier(
            uri=args.uri,
            version=document.version,
        ),
        edits=[
            types.TextEdit(
                new_text=f"{line.strip()} {answer}\n",
                range=types.Range(
                    start=types.Position(line=args.line, character=0),
                    end=types.Position(line=args.line + 1, character=0),
                ),
            )
        ],
    )

    # Apply the edit.
    ls.workspace_apply_edit(
        types.ApplyWorkspaceEditParams(
            edit=types.WorkspaceEdit(document_changes=[edit]),
        ),
    )

# Before
from pygls.server import LanguageServer
server = LanguageServer(name="my-language-server", version="v1.0")

# After
from pygls.lsp.server import LanguageServer
server = LanguageServer(name="my-language-server", version="v1.0")

# Before
from pygls.server import LanguageServer
server = LanguageServer(name="my-language-server", version="v1.0")
server.publish_diagnostics(uri='...', diagnostics=[...])

# After
from lsprotocol import types
from pygls.lsp.server import LanguageServer
server = LanguageServer(name="my-language-server", version="v1.0")
server.text_document_publish_diagnostics(
    types.PublishDiagnosticsParams(
        uri='...',
        diagnostics=[...],
    )
)

from lsprotocol import types
from pygls.server import LanguageServer

server = LanguageServer(name="my-language-server", version="v1.0")

@server.command('progress.example')
async def progress(ls: LanguageServer, *args):
    """Create and start the progress on the client."""
    token = str(uuid.uuid4())

    # Create
    await ls.progress.create_async(token)

    # Begin
    ls.progress.begin(
        token,
        types.WorkDoneProgressBegin(title="Indexing", percentage=0, cancellable=True),
    )

    # Report
    for i in range(1, 10):
        # Check for cancellation from client
        if ls.progress.tokens[token].cancelled():
            # ... and stop the computation if client cancelled
            return

        ls.progress.report(
            token,
            types.WorkDoneProgressReport(message=f"{i * 10}%", percentage=i * 10),
        )
        await asyncio.sleep(2)

    # End
    ls.progress.end(token, types.WorkDoneProgressEnd(message="Finished"))

from lsprotocol import types
from pygls.lsp.server import LanguageServer

server = LanguageServer(name="my-language-server", version="v1.0")

@server.command('progress.example')
async def progress(ls: LanguageServer, *args):
    """Create and start the progress on the client."""
    token = str(uuid.uuid4())

    # Create
    await ls.work_done_progress.create_async(token)

    # Begin
    ls.work_done_progress.begin(
        token,
        types.WorkDoneProgressBegin(title="Indexing", percentage=0, cancellable=True),
    )

    # Report
    for i in range(1, 10):
        # Check for cancellation from client
        if ls.work_done_progress.tokens[token].cancelled():
            # ... and stop the computation if client cancelled
            return

        ls.work_done_progress.report(
            token,
            types.WorkDoneProgressReport(message=f"{i * 10}%", percentage=i * 10),
        )
        await asyncio.sleep(2)

    # End
    ls.work_done_progress.end(token, types.WorkDoneProgressEnd(message="Finished"))