When it comes to binge-watching movies or shows, most of us are content to log on to Netflix and work our way through an entire series. Well, there’s another streaming service you should check out—Tubi.

But what exactly is Tubi TV? In short, it’s a streaming service that offers thousands of movies and TV shows—all for free. With a library that includes everything from cult classics to recent Hollywood hits, Tubi TV has quickly become a must-have for anyone looking to stream content for free.

But how does it work? And what makes Tubi TV stand out? Let’s find out.

What Is Tubi TV?

Tubi is a free streaming service owned by Fox Corporation. It has over 20,000 HD movies and TV shows. Not only this, but it’s also available on every major smart TV platform and all the popular streaming devices.

It features content from major studios, including MGM, Paramount, Lionsgate, as well as independent filmmakers. While it may not have the same buzz or extensive library as its competitors, it’s a great option for those looking for free streaming content.

To get started, you’ll need to sign up for Tubi with your email address or Google account. Next, you can create a watch list of your favorite movies, docuseries, TV shows, and more. You can access the service across Android and iOS devices, desktops, gaming consoles, and on the web as well.

Download: Tubi TV for Android | iOS | Web (Free)

What Content Can You Watch on Tubi TV?

From timeless classics to the latest releases, Tubi TV offers a diverse array of content. From anime series to TV shows to docuseries, it has an extensive library to cater to a variety of user preferences. It’s chock-full of age-appropriate entertainment available to keep kids engaged and entertained.

If you’re into action flicks or crime dramas, comedy or sci-fi flicks—you name it—you can find it on the site. It offers a vast collection of movies spanning various genres, including action, comedy, drama, horror, romance, and so on.

The content itself comes under several categories, including “Cult Classics,” “Award Winners and Nominees,” “Pre-School,” “Kids Shows,” “Highly Rated on Rotten Tomatoes,” and more.

How to Set Up and Use Tubi TV

To get started with Tubi, you’ll need to register for an account. Once you’ve signed in, open the app and hit Browse to bring up the main menu with the list of available titles, sub-categories, or channels.

With an interface similar to that of Netflix, each movie expands into its own viewer. This gives you more information about the film, including reviews, cast, and more. When you find one that interests you, just click it and start watching.

If you have a Roku streaming device or video game console like an Xbox One, just search for the native Tubi TV app using your device’s built-in search function.

In case you haven’t already, you’ll be prompted to create an account with your email address and password before browsing through available channels. You can always access Tubi TV on your web browser as well.

Since Tubi is supported in limited regions, such as the US, Canada, Mexico, Australia, and New Zealand, you can connect to a VPN and connect to US servers to view its content. We recommend checking out these privacy-friendly free VPNs to access geo-restricted content.

If you’re a parent, you can use the Parental controls feature to control what your children can watch on the app. It also allows you to edit how your subtitles appear, so you can customize the caption fonts and sizes to your liking.

How Is Tubi Different From Other Popular Streaming Services?

Tubi is a tad different from other popular streaming services such as Netflix and Amazon Prime. First off, these services charge a hefty subscription fee for access to content, while Tubi is completely free.

Moreover, Tubi’s selection of titles is unique in that it focuses on providing obscure movies and foreign films that you may not have heard of or seen before.

Thirdly, Tubi TV is widely available across a range of devices, including Roku, Android TV, Amazon Fire TV Stick, Xbox One, Xbox Series S, Xbox Series X, smart TVs, Chromecast, Amazon Echo Show, Google Nest Hub, Blu-ray players, and HiSense TVs. This allows you to watch your favorite content from anywhere as long as you have an internet connection.

Tubi TV: Get a Huge and Free Collection of Movie Titles

While there are plenty of other sites that offer free content, Tubi TV is quickly rising through the ranks as one of the top-rated sites in this space.

Regardless of your streaming preferences, you should keep Tubi at the top of your list. Yes, it has advertising, but unlike other free providers who interrupt programming with ads, Tubi TV can offer content with minimal interruptions and fewer ad loads, which can truly improve your entertainment experience.

Starting last week (May 12), OpenAI rolled out the plugins for ChatGPT plus users. This means that we can not only use the plugins from their store but also create our own plugins.

In this article, we will go through the process of creating a plugin for ChatGPT using Laravel.
The plugin will be a very simple web browser that will fetch the HTML content of a given URL, but this concept can be applied to any other use case.

Why a browser? Because it’s a simple example.

TL;DR: The code is available at github.com/juampi92/chatgpt-plugin-in-laravel.

Step 0 – Setup

Start by creating a new laravel project

composer create-project laravel/laravel chatgpt-browse-plugin
composer require guzzlehttp/guzzle

We will need the guzzlehttp/guzzle package to make HTTP requests using the Laravel HTTP Client.

Step 1 – Plugin configuration

ChatGPT requires us to have a plugin manifesto. This file is a JSON file that contains information about the plugin, such as the name, description, logo, etc.
We will need to locate it in the following URL localhost:8000/.well-known/ai-plugin.json.

For reasons that will be explained later, we will create the file inside resources/ instead of public.

mkdir resources/.well-known
touch resources/.well-known/ai-plugin.json

{
    "schema_version": "v1",
    "name_for_human": "My Local Web Browser Plugin",
    "name_for_model": "MyLocalWebBrowser",
    "description_for_human": "Plugin for browsing the web locally in the name of ChatGPT.",
    "description_for_model": "Plugin for browsing websites locally and getting their content.",
    "auth": {
        "type": "none"
    },
    "api": {
        "type": "openapi",
        "url": "http://localhost:8000/openapi.yaml",
        "is_user_authenticated": false
    },
    "logo_url": "http://localhost:8000/logo.png",
    "contact_email": "support@example.com",
    "legal_info_url": "http://www.example.com/legal"
}

Notes:

• If you decide to use a different port, make sure to update the url fields (api.url and logo_url).
• Also, if you decide to use a different name, make sure name_for_model doesn’t have any spaces.

To make the file available to the public, we need to do two things:

1. Update the routes in routes/web.php:

Route::get('.well-known/ai-plugin.json', fn () =>
    File::get(resource_path('.well-known/ai-plugin.json')));

2. Update config/cors.php to have 'paths' => ['*'],.

The reason why we can’t use the /public directory is because
the plugin will be hosted on a different domain and the browser
will block the request due to CORS.
If you intend to host the plugin on a server, you can use
the /public directory and configure apache/nginx to allow
CORS on static files.

Step 2 – Making it browse

Now we need to create the API that will be used by ChatGPT to browse the web.

Let’s create a new controller:

php artisan make:controller BrowseController

And the content of the controller should look something like this:

use Illuminate\Support\Facades\Http;

public function __invoke(Request $request): JsonResponse
{
    ['url' => $url] = $request->validate([
        'url' => 'required|url',
    ]);

    $response = Http::withHeaders([
            'User-Agent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36',
        ])
            ->get($url);

    return new JsonResponse([
        'response' => $response->body(),
    ]);
}

Add the controller to routes/api.php:

Route::get('/browse', BrowseController::class);

Step 3 – API Documentation

In order for ChatGPT to understand how to use our plugin,
we need to generate an OpenAPI specification.
GPT will read the specification and decide when and how to use your endpoints,
so it’s important that the API is clear.

To generate the actual yaml file, we will use the zircote/swagger-php package.

composer require zircote/swagger-php --dev

Now we need to update the Controller using the OpenApi Annotations:

/**
 * @OA\Info(title="MyLocalWebBrowserAPI", version="0.1")
 */
class BrowseController extends Controller
{
    /**
     * @OA\Get(
     *     path="/api/browse",
     *     summary="Get HTML content of an URL",
     *     @OA\Parameter(
     *         name="url",
     *         in="query",
     *         description="URL to fetch the HTML from",
     *         required=true,
     *         @OA\Schema(
     *             type="string",
     *             example="http://example.com"
     *         )
     *     ),
     *     @OA\Response(
     *         response=200,
     *         description="HTML content of the URL",
     *         @OA\JsonContent(
     *            type="object",
     *            required={"response"},
     *            @OA\Property(
     *              property="response",
     *              type="string",
     *              description="Raw HTML content of the URL"
     *           )
     *         )
     *     )
     * )
     */

To generate our OpenAPI specification, we run the following:

./vendor/bin/openapi app -o resources/openapi.yaml

And, for the same reasons mentioned before, add
the following route to routes/web.php:

Route::get('openapi.yaml', fn () =>
    File::get(resource_path('openapi.yaml')));

Step 4 – Serving

To run our plugin, simply call

php artisan serve --port=8000

Step 5 – Installing the plugin

Now that we have our plugin ready, we need to install it in ChatGPT.
When creating a new GPT-4 chat, you can click on the “Plugins” button and then go to the Plugin store.

From there, we go to the Plugin Store, and at the bottom, we click on Develop your own plugin.

Here we are presented with a form to fill in the domain of our plugin. We input localhost:8000 (if you changed the port, make sure to use the correct one).

If everything went well, you will see the following screen:

Step 6 – Using the plugin

Now that we have our plugin installed, we can use it in our chat.

ChatGPT will decide when to use your plugin depending on your description and OpenAPI specification,
so in the case of our browser plugin, simply giving a URL will do.

You might be wondering: why not just use WebPilot, the plugin that comes with ChatGPT?

The truth is that you can use WebPilot. The only difference is that
WebPilot uses a hosted server to browse. A server that can be rate-limited by websites, and you can’t customize.

This is an example using WebPilot:

And here is with our plugin:

Conclusion

In this simple article, we saw how to create a plugin for ChatGPT using Laravel.

If you would like to see the whole code, you can find it here: juampi92/chatgpt-plugin-in-laravel. I added a few more features, like transforming the content into markdown, so there is less content to send to ChatGPT, and so hitting the characters limit less often.

Laravel 10 Eloquent Mutators and Accessors

The mutator modifies the value before inserting it into the database, while the accessor modifies the value after fetching it from the database. Mutator and accessor can be defined in the same method.

Let’s suppose, the customer’s name should be stored in lowercase and displayed in Pascal case (with space) even if the customer puts a name with capitalized letters. To do that, we will need to use a mutator and accessor in the Model. The mutator will be converting the customer name into lowercase before inserting it in the database and the accessor will be converting it into Pascal case before displaying it.

You can define a mutator and accessor in the Model file in the app/Models directory. We added two additional columns first_name and last_name into the users table through migration. By default, Laravel creates a name column in the users table.

Mutator

The Mutator allows you to modify the value before inserting it into the database. For example, if you want, the first and last should always be stored in lowercase in the database then mutator is the best way to do it.

Define Mutator:

To define a mutator it is necessary to create a method using the column’s name written in the camel case. Let’s take an example: if the column name is first_name then the method name should be firstName().

In the earlier versions of Laravel, it is required to add a set at the beginning of the method and an attribute keyword at the end of the method. But in Laravel versions 9 and 10 it is no longer required.

Let’s create a mutator for the first_name column in the User model class from app/Models directory.

Before adding the above mutator method in the model class make sure the Attribute class is imported. You can import the attribute class through the below namespace

use Illuminate\Database\Eloquent\Casts\Attribute;

protected function firstName(): Attribute
{
    return Attribute::make(
        set: fn (string $value) => strtolower($value),
    );
}

The above mutator method will be converting the value of the first_name column into lowercase before inserting it into the database.

In this method, we used the make() method of the Attribute class that takes two optional parameters get and set. We passed a callback function to the set parameter that takes a string and converts it into lowercase through PHP built-in function strtolower().

Now look at the below profile update form where the first name is in capitalized letters that should be inserted in the lowercase through the mutator.

Let’s check the inserted row in the database.

In the above screenshot of the users table the first_name value is inserted in lowercase.

Accessor

The accessor allows you to modify the value before being accessed. To define an accessor, similar to a mutator, it is essential to create a method using the column’s name in the camelcase.

Define Accessor:

Let’s create an accessor for the first_name column that should capitalize the first letter of each word.

protected function firstName(): Attribute
{
    return Attribute::make(
        get: fn (string $value) => ucwords($value),
    );
}

In the above accessor method, we used the make() method from the attribute class in which we passed a callback function to the get parameter. The callback function takes the value and converts capitalize the first letter of each word through the PHP built-in function ucwords().

To check if the accessor is working, we can print the first_name column’s value in the controller.

echo $request->user()->first_name;
// Output: Emily

As you can see the first_name value “Emily” is stored in the lowercase through the mutator, but in the controller accessor capitalized the first letter.

Accessor and mutator can be defined in the same method. Look at the below method in which we defined the accessor and mutator together.

protected function firstName(): Attribute
{
    return Attribute::make(
        get: fn (string $value) => ucwords($value),
        set: fn (string $value) => strtolower($value),
    );
}

---

Related Posts

The Legend of Zelda: Tears of the Kingdom features a lot of items. It carries over staples from Breath of the Wild like food and monster parts, and adds plenty of new options from bomb flowers to Zonai devices. You really can’t have enough items in this game, which makes this item duplication glitch so useful.

The glitch, as outlined by IGN, isn’t necessarily hard to pull off, but it does require precision. My advice is to read through the instructions first, then give it a shot. If you don’t get it right away, be patient and give it another go.

How to glitch your way to unlimited items in Tears of the Kingdom

To start, make sure you have a bow equipped. Draw your arrow by tapping R2, then attach the item you’re looking to duplicate by holding the up button. Personally, I’m not going to choose any brightbloom seeds because I have so many, but I could use more bomb flowers, so I went with that.

With your item equipped, wait a beat, press +, then head over to the Bows and Arrows section of the menu. Select the bow you have equipped, then Drop it. Without leaving the menu, equip a new bow, then press + two times as quickly as possible. You want to make it back to the menu without the bow falling to the ground. Now, drop the newly equipped bow, and finally exit the menu for good.

If done correctly, the two bows should be stacked on top of each other. Pick them both up, then check your items. You should have one extra item than you started with.

IGN details two other item duplication efforts—one for duplicating equipment in your inventory and another for copying equipment you haven’t come across before. But these methods are more complicated, and actually risk losing items in the process. For safe item duplication, stick to the first glitch.

There were fears that this glitch would be patched in the latest update, version 1.1.1., but that doesn’t appear to be the case. Even after installing the update, the game still lets you copy your items, which means Nintendo is either unaware of the glitch or feels it low priority enough not to fix yet. Hopefully they never fix it and allows the fun glitch to be among the very few bugs in a remarkably polished game.

A 10-year-old child spent over $3000 on Roblox via the family iPad, charges applied after the child changed the account password.

Software design is an essential phase in software development. The design approach can affect the entire project and how you handle different requirements.

Developers have often used a monolithic architecture, bundling up all the software components into a single module. However, this approach can prove inefficient, particularly for larger applications.

Microservices aim to address these limitations. A microservice is a small, modular application that performs specific functions. Unlike monolithic applications, microservices allow for independent deployment and scaling. As a result, they are more flexible and easier to maintain.

The Microservice Architecture

The microservice architecture is a software design approach that breaks down a large application into independent services, with each service designed to address a specific business requirement.

These services run on dedicated resources, including separate database instances and computing power. Unlike monolithic systems, microservice applications are loosely coupled allowing for greater flexibility.

In a distributed system, server nodes deploy and execute microservice applications as separate processes—communicating with each other using communication protocols such as HTTP or via message brokers like RabbitMQ.

Essentially, this architectural approach enables the services to maintain their independence from one another while effectively operating within the software system.

In this tutorial, we’ll guide you through implementing a simple user microservice that manages user data using Flask and PostgreSQL

Set Up a PostgreSQL Database

To get started, install PostgreSQL. If you don’t have PostgreSQL installed, you can find out how to install PostgreSQL on Windows or how to install PostgreSQL on macOS.

Alternatively, you can configure a remote PostgreSQL database instance.

This guide will use Render’s free tier to set up a PostgreSQL database. Follow these to spin up a PostgreSQL database instance on Render:

1. Head over to Render’s website, sign up for an account, and log in to your dashboard page.
2. On your dashboard page, from the list of services displayed, select the PostgreSQL service.
3. On the database settings page, fill in the required details and make sure to select the free tier, and finally click Create database.

Create a Flask Microservice

1. In your terminal, make a new directory and change into it:

    mkdir flask-microservice
   cd flask-microservice 

2. Next, install virtualenv, to create an isolated virtual development environment.

    pip install virtualenv 

3. Create a virtual environment in your project:

    virtualenv venv 

4. Finally, activate the virtual environment.

    # Windows: 
   .\venv\Scripts\activate
   # Unix or MacOS: 
   source venv/bin/activate 

Install the Required Packages

1. Create a new requirements.txt file in the root directory and add these packages:

    flask
   psycopg2-binary
   sqlalchemy 

2. Next, install the packages.

    pip install -r requirements.txt 

Create a Flask Server

In the root directory, create a new file: service.py, and the following code:

1. Make the following imports:

    from flask import Flask, request, jsonify
   from sqlalchemy import create_engine, Column, Integer, String
   from sqlalchemy.orm import sessionmaker
   from sqlalchemy.ext.declarative import declarative_base
   import psycopg2 

2. Create the Flask instance and configure the database connection.

    app = Flask(__name__)
   
   engine = create_engine("postgresql+psycopg2://flask_service_fe0v_user:4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v") 

   Copy the external database URL on Render’s database settings page. We’ll use the SQLAlchemy create_engine method and Psycopg2 to configure the database connection. Make sure to update and replace the database URL in the above code with the URL of your own PostgreSQL instance that matches the format specified above. If the URL format is incorrect, the code will throw an error.

3. Create an SQLAlchemy model for the database.

    Base = declarative_base()
   class User(Base):
       __tablename__ = 'users'
       id = Column(Integer, primary_key=True)
       name = Column(String(50))
   Base.metadata.create_all(engine)
   print("Table 'users' created successfully.")
   Session = sessionmaker(engine) 

   The code defines a data model for the users’ table. After defining the model, it creates the table using the SQLAlchemy create_all method which takes the database connection engine object as a parameter. Finally, it creates an instance of the session maker using the same engine object to enable interactions with the database.

4. Lastly, define the API routes for the microservice.

    @app.route("/api/user", methods=["POST"])
   def create_user():
       data = request.get_json()
       name = data["name"]
       try:
           session = Session()
           new_user = User(name=name)
           session.add(new_user)
           session.commit()
           return {"id": new_user.id, "name": new_user.name, "message": f"User {name} created."}, 201
       except Exception as e:
           print(f"The error '{e}' occurred.")
           return {"error": "An error occurred while creating the user."}, 500
   @app.route("/api/user", methods=["GET"])
   def get_all_users():
       try:
           session = Session()
           users = session.query(User).all()
           if users:
               result = []
               for user in users:
                   result.append({"id": user.id, "name": user.name})
               return jsonify(result)
           else:
               return jsonify({"error": f"Users not found."}), 404
       except Exception as e:
           print(f"The error '{e}' occurred.")
           return {"error": "An error occurred while getting all users."}, 500
   if __name__ == "__main__":
       app.run(debug=True, host="0.0.0.0") 

Test the Microservice

The above code demonstrates a simple user data microservice that adds and fetches data from a PostgreSQL database. Ideally, microservices mirror the REST API architecture since it allows for a flexible approach to building web services—this architecture fits well with the design pattern of microservices.

However, it’s important to note that microservices can use other types of design approaches and communication protocols as well, depending on the specific needs of the system.

To test the service, spin up the development server and head over to Postman to make HTTP requests to the defined endpoints.

 flask --app service run 

In Postman, make a POST request to add user data.

Containerizing Microservices With Docker

Docker bundles applications and their dependencies in containers. This approach streamlines the development, deployment, and management of microservices in a production environment since each service can operate independently and communicate with other services using the configured communication protocol.

Before you get started, you need to first install Docker by following the steps on the Docker website. Then, build a Docker image from a Dockerfile that contains the necessary instructions for setting up the required dependencies to run the application in a container.

1. Create a Dockerfile in your project folder’s root directory and add these instructions:

    FROM python:3.9-alpine
   WORKDIR /app
   COPY requirements.txt ./
   RUN pip install -r requirements.txt
   COPY . .
   EXPOSE 5000
   CMD ["python", "./service.py"] 

2. Run, the command below to build the Docker image.

     docker build -t flask-microservice . 

3. Finally, run the Docker container.

    docker run -p 5000:5000 flask-microservice 

This will start a Docker container running the Flask microservice and expose port 5000 on the container to port 8000 on the host machine, allowing you to make HTTP requests from your web browser or Postman using the URL http://localhost:5000.

Adopting the Microservice Architecture

Microservices architecture has become a popular approach for developing scalable and robust software applications. By dividing the application into small, independently deployable services, microservices architecture makes it easier to maintain and scale the system.

While this architecture has potential benefits, it’s not suitable not for all use cases. In any case, the specific business requirements of the project should primarily influence the adopted design approach.