Skip to content

EugoIDE

Welcome to EugoIDE, where work gets done. EugoIDE is the powerhouse integrated development environment (IDE) designed to elevate your coding experience. EugoIDE is a full-featured IDE tailored to supercharge your workflow with cutting-edge tools, seamless integrations, and high-performance computation.

Code as you normally would, and let EugoIDE handle the rest. With EugoIDE, you can focus on writing code, building models, and optimizing algorithms, while Eugo takes care of the heavy lifting, from runtime efficiency to resource management. With a comprehensive suite of development tools, flexible configurations, and integration options, EugoIDE is crafted to support your existing coding style.

Example - Using the EugoIDE
from pathlib import Path
from uuid import uuid4

from aws_lambda_powertools.logging import Logger # (1)!
from fsspec import filesystem

svc_name = "eugo_example"
logger = Logger(svc_name)


class S3Data:
    def __init__(
        self, *, source_bucket: str, source_key_prefix: str, destination_bucket: str
    ) -> None:
        self.source_bucket = source_bucket # (2)!
        self.source_key_prefix = source_key_prefix
        self.destination_bucket = destination_bucket
        self.s3fs = filesystem("s3") # (3)!
        self.source_path_remote_prefix = (
            f"{self.source_bucket}/{self.source_key_prefix}"
        )
        self.source_local_path = f"/tmp/eugo/{self.source_path_remote_prefix}"

    def get_data(self):
        num_bytes = 1024

        source_size_in_gigabytes = round( # (4)!
            float(self.s3fs.du(self.source_path_remote_prefix))
            / num_bytes
            / num_bytes
            / num_bytes,
            2,
        )
        logger.info(
            f"Using a folder w/ multiple datasets at '{self.source_path_remote_prefix}' w/ the size of {source_size_in_gigabytes}GB."
        )

        Path(self.source_local_path).parent.mkdir(parents=True, exist_ok=True)
        self.s3fs.get(self.source_path_remote_prefix, self.source_local_path) # (5)!

    def put_data(self):
        destination_key_prefix = f"interactive_session_tests/{uuid4()}"
        logger.info(destination_key_prefix)
        self.s3fs.put( # (6)!
            self.source_local_path,
            f"{self.destination_bucket}/{destination_key_prefix}",
        )


s3_data = S3Data(
    source_bucket="example_read_remote_bucket",
    source_key_prefix="example_key_prefix",
    destination_bucket="example_read_remote_bucket",
)

s3_data.get_data()
s3_data.put_data()
  1. import any of the 1000s of libraries available in EugoIDE. In this case, we are using the aws_lambda_powertools.logging.Logger to log messages.
  2. Define the source bucket.
  3. Initialize the s3fs object to interact with an S3 bucket.
  4. Calculate the size of the source data and log it.
  5. Get the data from the source bucket and save it locally.
  6. Write the data to the destination bucket.

Examples

With access to a vast library of optimized tools and features, EugoIDE is your go-to workspace for coding, debugging, and optimizing your projects. Whether you're building machine learning models, developing web applications, or running complex simulations, EugoIDE provides the tools you need to bring your ideas to life.

After you've created your EugoIDE workspace, you can start coding right away. We provide you with hundreds of off-the-shelf demo notebook examples to get you started. Here are a few:

Data Processing Example with Pandas and AWS Wrangler

import awswrangler as wr
import boto3
import pandas as pd
from datetime import date

boto3.setup_default_session(region_name="us-east-2")
wr.s3.does_object_exist("s3://noaa-ghcn-pds/fake", boto3_session=my_session)

bucket = "eugo-example-data"
path = f"s3://{bucket}/test/"

df = pd.DataFrame({
    "id": [1, 2],
    "value": ["foo", "boo"],
    "date": [date(2020, 1, 1), date(2020, 1, 2)]
})

wr.s3.to_parquet(
    df=df,
    path=path,
    dataset=True,
    mode="overwrite"
)

data = wr.s3.read_parquet(path, dataset=True)
print(data)

User Model Validation Example with Pydantic

This example demonstrates how to validate user data using Pydantic's BaseModel. The code below attempts to create a User instance from external data that doesn't meet the expected format.

from datetime import datetime
from pydantic import ValidationError, BaseModel, PositiveInt

class User(BaseModel):
    id: int
    name: str = 'John Doe'
    signup_ts: datetime | None
    tastes: dict[str, PositiveInt]

external_data = {'id': 'not an int', 'tastes': {}}

try:
    User(**external_data)
except ValidationError as error:
    print(error.errors())

When the above code is executed, it will raise a ValidationError, resulting in the following output:

[
    {
        "type": "int_parsing",
        "loc": ["id"],
        "msg": "Input should be a valid integer, unable to parse string as an integer",
        "input": "not an int",
        "url": "https://errors.pydantic.dev/2/v/int_parsing"
    },
    {
        "type": "missing",
        "loc": ["signup_ts"],
        "msg": "Field required",
        "input": {"id": "not an int", "tastes": {}},
        "url": "https://errors.pydantic.dev/2/v/missing"
    }
]

Runtime

Eugo always has the latest and greatest. Our runtime comes with Python 3.12.6, and we'll upgrade to 3.13.X once all of our dependencies are compatible.

Key Features

  • Code Completion & Syntax Highlighting EugoIDE brings you intuitive code completion and syntax highlighting to boost coding efficiency. With support for Python, EugoIDE helps you write, read, and debug code effortlessly.

  • Type Hinting Built-in type hinting enhances code accuracy and readability, guiding you with visual cues and suggestions. Whether you're writing complex algorithms or simple scripts, type hinting in EugoIDE reduces errors and ensures robust code structure.

  • Amazon Q Integration (Optional) For users leveraging Amazon Q, EugoIDE provides optional integration, offering direct access to high-speed quantum-inspired computing capabilities within your IDE workspace.

EugoUmbrella: The Hyper-Optimized Computation Engine

At the core of EugoIDE is EugoUmbrella, our hyper-optimized computation engine designed to handle intense data processing and optimization tasks. With EugoUmbrella, you can focus on writing code, and let Eugo take care of high-performance execution and optimization. Simply offload your computations to EugoUmbrella, and let it handle everything from runtime efficiency to resource management.

Getting Started

Ready to dive in? Start your journey with EugoIDE by signing up for Eugo and selecting the tier that best suits your requirements.

For more details on Eugo's libraries and customization options, visit our Library Overview.

With EugoIDE, bring your ideas to life with unparalleled speed and efficiency. Write, compute, and let Eugo handle the rest.