Posted on mongodb google news. Visit mongodb google news

Firestore developers can now take advantage of MongoDB’s API portability along with Firestore’s differentiated serverless service, to enjoy multi-region replication with strong consistency, virtually unlimited scalability, industry-leading high availability of up to 99.999% SLA, and single-digit milliseconds read performance.

See live demos of how to:

• Use Firestore with MongoDB compatibility, along with the upcoming data interoperability features to leverage Firestore’s real-time and offline SDKs side-by-side
• Use Firestore migration tooling to connect to your existing document databases and perform streaming migrations to Firestore
• How Firestore’s customer-friendly serverless pricing enables you to save on total cost of operations (TCO)

Register Now to attend the webinar Hands On: Firestore With MongoDB Compatibility in Action.

Don’t miss this live event on Tuesday, June 10th, 11 AM PT / 2 PM ET.

---

SPEAKERS				MODERATOR
Minh Nguyen Senior Product Manager Google Cloud		Patrick Costello Engineering Manager Google Cloud		Stephen Faig Research Director Unisphere Research and DBTA

Article originally posted on mongodb google news. Visit mongodb google news

Posted on mongodb google news. Visit mongodb google news

Interested in diving into our Django MongoDB Backend integration? Follow along with this quickstart to create a Django application, connect that application to a MongoDB deployment, ensure your deployment is hosted on MongoDB Atlas, and interact with the data stored in your database using simple CRUD operations.

What is Django?

Let’s first go over what Django is. Django is a high-speed model-view-controller framework for building web applications. There are a ton of key benefits of utilizing Django in projects, such as rapid development, a variety of services to choose from, great security, and impressive scalability. Django prides itself on being the best framework for producing flawless work efficiently. As we’ll see throughout this quickstart, it’s incredibly simple to get up and running with our Django MongoDB Backend integration.

Pre-requisites

To be successful with this quickstart, you’ll need a handful of resources:

• An IDE. This tutorial uses Visual Studio Code.
• Python 3.10 or later. We recommend using 3.12 in the environment.
• A MongoDB Atlas cluster.

Create Your MongoDB Cluster

Please follow the steps to create a MongoDB cluster on our free tier cluster, which is free forever. Please make sure that the “Network Settings” are correctly set up for easy connection to the cluster, and that a secure username and password have been chosen. Once the cluster is configured, please make sure the connection string is in a safe place for later use. 

Load the sample data into the cluster, and in the connection string, specify a connection to the sample database we are using, sample_mflix. Do this by adding the name of the database after the hostname, as shown in the code snippet below:

mongodb+srv://:@samplecluster.jkiff1s.mongodb.net/?retryWrites=true&w=majority&appName=SampleCluster

Now that our cluster is ready, we can create our virtual environment!

Create Your Virtual Environment

Our first step is to create our Python virtual environment. Virtual environments allow us to keep the necessary packages and libraries for a specific project in the correct environment without having to make changes globally that could impact other projects. 

To do this, run:

python3.12 -m venv venv

Then, run:

source venv/bin/activate

Once the (venv) is next to the directory name in the terminal, the virtual environment is correctly configured. Make sure that the Python version is correct (3.10 and above) by double-checking with:

python —version

Once the virtual environment is set up, we can install our Django integration! 

Installing Django MongoDB Backend

To install the Django integration, please run the following command from the terminal:

pip install django-mongodb-backend

If both PyMongo and Django are installed in the environment, please ensure that the PyMongo version is between 4.6 and 5.0, and that the Django version is between 5.0 and 5.1. 

When correctly run, this is what we’ll see in our terminal:

Once this step is complete, our integration is correctly downloaded along with the dependencies that include Django and PyMongo required for success. 

Create Your Django Project!

We’re all set up to create our Django project. This django-mongodb-project template is about the same as the default Django project template, with a couple of important changes. It includes MongoDB-specific migrations, and the settings.py file has been modified to make sure Django uses an ObjectId value for each model’s primary key. It also includes MongoDB-specific app configurations for Django apps that have default_auto_field set. This library allows us to create our own apps so we can set django_mongodb_backend.fields.ObjectIdAutoField. 

Run this command to create a new Django project called quickstart:

django-admin startproject quickstart --template https://github.com/mongodb-labs/django-mongodb-project/archive/refs/heads/5.0.x.zip

Once this command is run, it will show up on the left-hand side of the project file:

Once you can see the quickstart project, it’s time to update our database settings. To do this, go to the settings.py file under the quickstart folder and head over to the DATABASES setting. Replace the ”” with the specific cluster URI, including the name of the sample database:

DATABASES = {
  "default": django_mongodb_backend.parse_uri(""),
}

Now, we can make sure that we have correctly installed the Django MongoDB Backend and our project is properly set up. Make sure to be in the quickstart folder and run this command:

python manage.py runserver

Click on the link or visit http://127.0.0.1:8000/. On this page, there will be a “Congratulations!” and a picture of a rocket:

Now that we know our setup has been successful, we can go ahead and create an actual application where we can interact with the sample data we previously downloaded! Let’s dive in. 

Creating an Application for Our “sample_mflix” Data

We are first going to create our sample_mflix application. Head into the root directory of your project and run this command to create an application based on our custom template:

python manage.py startapp sample_mflix --template https://github.com/mongodb-labs/django-mongodb-app/archive/refs/heads/5.0.x.zip

The django-mongodb-app template makes sure that your apps.py file includes the line: “default_auto_field = ‘django_mongodb.fields.ObjectIdAutoField’”. This ensures that instead of using the original Django BigAutoField for IDs, we are using MongoDB’s specific ObjectId feature.

Once you create your project, we are going to create models for our movie, viewer, and award data. 

Create Models for Our Movie, Viewer, and Award Data

To create data models, all we have to do is open up our models.py file inside of our newly created sample_mflix directory and replace the entire file with the following code.

from django.db import models
from django.conf import settings
from django_mongodb_backend.fields import EmbeddedModelField, ArrayField
from django_mongodb_backend.models import EmbeddedModel

class Award(EmbeddedModel):
    wins = models.IntegerField(default=0)
    nominations = models.IntegerField(default=0)
    text = models.CharField(max_length=100)

class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    awards = EmbeddedModelField(Award, null=True, blank=True)
    genres = ArrayField(models.CharField(max_length=100), null=True, blank=True)

    class Meta:
        db_table = "movies"
        managed = False

    def __str__(self):
        return self.title

class Viewer(models.Model):
    name = models.CharField(max_length=100)
    email = models.CharField(max_length=200)

    class Meta:
        db_table = "users"
        managed = False

    def __str__(self):
        return self.name

The Movie model here represents our sample_mflix.movies collection and stores information about various movies! The Viewer model, on the other hand, represents the sample_mflix.users collection and stores important user details for a movie streaming platform. The Award model represents the embedded document values that are stored in the Movie model. 

Once this is done and the models.py file is saved, let’s create views to display our data. 

Create Views to Display Our Data

To display data from the sample_mflix database, we’ll add views to the  views.pyfile. Open it up from your sample_mflix directory and replace the contents with the code below. 

Here, we are displaying a landing page message and information about the Movieand Viewer models we configured above:

from django.http import HttpResponse
from django.shortcuts import render

from .models import Movie, Viewer

def index(request):
   return HttpResponse("Hello, world. You're at the application index.")

def recent_movies(request):
   movies = Movie.objects.order_by("-released")[:5]
   return render(request, "recent_movies.html", {"movies": movies})

def viewers_list(request):
   viewers = Viewer.objects.order_by("name")[:10]
   return render(request, "viewers_list.html", {"viewers": viewers})

Once we have finished this section, we are ready to move on and configure URLs for our views. 

Configure URLs for Our Views

To be successful in this section, we need to create a new file called urls.py inside of our sample_mflix directory. This file maps the views we defined in the previous step to dedicated URLs.

Copy the code below into this new file:

from django.urls import path

from . import views

urlpatterns = [
   path("recent_movies/", views.recent_movies, name="recent_movies"),
   path("viewers_list/", views.viewers_list, name="viewers_list"),
   path("", views.index, name="index")
]

Once that has been copied in, we can go ahead to our quickstart/urls.py file and replace the file’s content with the code below:

from django.contrib import admin
from django.urls import include, path

urlpatterns = [

   path("admin/", admin.site.urls),
   path("", include("sample_mflix.urls")),
]

Once we’ve finished replacing the file’s content, we can create templates to properly format our data. 

Create Templates to Format Your Data

First, create a templates subdirectory inside of the sample_mflix directory. Once this subdirectory is created, create a recent_movies.html file inside it. We are going to copy the following code to format the movie data requested by the recent_movies view:

  
  
  


  
Five Most Recent Movies
  

     {% for movie in movies %}
           

              {{ movie.title }} (Released: {{ movie.released }})
           
     {% empty %}
           
No movies found.
     {% endfor %}
  

Create another file in this same templates subdirectory and call it viewers_list.html. This template formats the user data that is requested by our viewers_list view. Copy the following code:

  
  
  


  
Alphabetical Viewers List
  
           {% for viewer in viewers %}
              
           {% empty %}
              
           {% endfor %}
     

     

           

              
Name
              
Email
           
     
     

                 
{{ viewer.name }}
                 
{{ viewer.email }}
              

                 
No viewer found.
              
  

Now that your templates are in place, we can include our application inside our project! 

Including Our Application Inside Our Project

To do this, head over to the settings.py file nested in the quickstart directory and edit the INSTALLED_APPS section to look like this:

INSTALLED_APPS = [
   'sample_mflix.apps.SampleMflixConfig',
   'quickstart.apps.MongoAdminConfig',
   'quickstart.apps.MongoAuthConfig',
   'quickstart.apps.MongoContentTypesConfig',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
]

Once that has been done, we can create migrations for our new models. 

Create Migrations for Your New Models

We want to create migrations for our Movie, Award, and Viewer models and apply all these changes to the database. Head back to the root of your project and run the following commands:

python manage.py makemigrations sample_mflix
python manage.py migrate

Once the migrations are created, we have a basic Django MongoDB backend application! We can use this simple application to interact with our sample_mflixdatabase. This means running basic CRUD operations on the data. 

So, let’s go over how to do that. 

Write Data

We are going to be working with a Python shell, so head back into the project’s root directory and bring up the shell with this command:

python manage.py shell

Once you’re in your shell, we can import the necessary classes and modules for creating a datetime object. Do this by running the code below:

from sample_mflix.models import Movie, Award, Viewer
from django.utils import timezone
from datetime import datetime

Now, we’re ready to insert a movie into our database! We can do this by running the code below to create a Movie object that stores data about a movie named “Minari”, including its awards:

movie_awards = Award(wins=122, nominations=245, text="Won 1 Oscar")
movie = Movie.objects.create(
   title="Minari",
   plot="A Korean-American family moves to an Arkansas farm in search of their own American Dream",
   runtime=217,
   released=timezone.make_aware(datetime(2020, 1, 26)),
   awards=movie_awards,
   genres=["Drama", "Comedy"]
)

This Movie object actually stores incorrect data about the movie: the runtime value is listed as 217, but the correct value is 117.

Let’s fix this by running the code below:

movie.runtime = 117
movie.save()

Now, let’s insert a viewer into our database as well. We can do this by creating a Viewer object that stores data about a viewer named “Abigail Carter”. Run the following code to do so:

viewer = Viewer.objects.create(
   name="Abigail Carter",
   email="[email protected]"

)

Let’s delete a Viewer object. A movie viewer by the name of “Alliser Thorne” is no longer a member of the movie streaming service. To remove this viewer, run the code below:

old_viewer = Viewer.objects.filter(name="Alliser Thorne").first()
old_viewer.delete()

Once that’s done, exit your shell using this command:

exit()

Ensure we are in the quickstart directory, and start the server using this command:

python manage.py runserver

Great! We can now go and make sure our Movies model was correctly inserted into the database. Do this by accessing the link: http://127.0.0.1:8000/recent_movies/

This is what you’ll see, with our latest movie right on top:

Let’s check our Viewer model, as well. Visit the link: http://127.0.0.1:8000/viewers_list/. 

There will be a list of 10 viewer names in our database. “Abigail Carter” will be at the top, and the viewer “Alliser Thorne” will have been deleted:

Once these steps have been completed, documents in the sample_mflix sample database will have been inserted and edited. 

Now, we can query the data inside our database. 

Reading Back Our Data

Open up your Python shell again, and please make sure that you have imported the necessary modules from when you first created the Python shell back under the step, “Write Data.”

from sample_mflix.models import Movie, Award, Viewer
from django.utils import timezone
from datetime import datetime

Once your shell is ready to go, we can query our users collection for a specific email. 

We want to query our sample_mflix.users collection for a user with the email ”[email protected]”. Do this by running the following:

from sample_mflix.models import Movie, Viewer

Viewer.objects.filter(email="[email protected]").first()

This will return the name of our user:

Now, let’s query our movie collection for runtime values. 

In the same shell, run the following code to find movies that have a runtime value that is less than 10:

Movie.objects.filter(runtime__lt=10)

This will return a list of matching movies, as seen in the screenshot below:

Once this step is finished, feel free to run queries on any data stored inside the MongoDB cluster!

Let’s Create an Admin Site

It’s possible to create a Django admin site so that users can edit their data straight from a web interface. 

Let’s first create an admin user. From the root directory, run the following code:

python manage.py createsuperuser

The terminal will ask for a username, email address, and password. Enter the following information below to create a user with specified credentials:

Username: admin
Email address: [email protected]
Password: 
Password (again): 

To enter the admin site, run the following code:

python manage.py runserver

Access the site by visiting http://127.0.0.1:8000/admin/. A login screen will appear:

Enter the name and password that were created previously to log on.

Here, the following information is presented, and users can edit their project authentication configuration through a selection of the Groups or Users rows in the Authentication and Authorization table. 

Let’s edit the data in our users sample collection. Remember that this is represented by the Viewer model, which is not associated with the Users row as shown in the admin panel. 

Head to the sample_mflix/admin.py file and paste in the code below:

from django.contrib import admin

from .models import Viewer

admin.site.register(Viewer)

Refresh the Django administration site, and it will be updated:

Now, we are able to select a viewer object. Do this by clicking on the Viewers row of the SAMPLE_MFLIX table to see the list of viewers, as seen below:

At the top of the list, click on Abigail Carter. From here, we will be able to see the Name and Email.

Here, we are able to edit the information, if chosen. Users are able to edit any field and hit the SAVE button to save any changes. 

Great job, you have just completed the Django MongoDB Backend Quickstart! In this quickstart, you:

• Created a Django application. 
• Connected your Django application to a MongoDB deployment. 
• Ensured your deployment is hosted on MongoDB Atlas. 
• Interacted with the data that is stored inside your cluster.
• Created a Django admin page.

To learn more about Django MongoDB Backend, please visit the docs and our repository on GitHub.

This article is written by Anaiya Raisinghani (Developer Advocate @ MongoDB) and Nora Reidy (Technical Writer @ MongoDB).

Article originally posted on mongodb google news. Visit mongodb google news

Posted on nosqlgooglealerts. Visit nosqlgooglealerts

CloudBees has announced it has brought its multiple standalone products together under a single platform called CloudBees Unify.

According to the company, CloudBees unifies acts like a layer on top of existing toolchains, and it uses an open and modular architecture to connect to other tools like GitHub Actions and Jenkins. 

Key features include a unified control plane, progressive adoption model, continuous security scanning, AI-driven testing, and artifact traceability and unified releases. 

“Since our founding, we’ve been partnering with the world’s most complex organizations to help them deliver software with speed, safety, and choice,” said Anuj Kapur, CEO of CloudBees. “CloudBees Unify builds on that foundation of trust and openness, giving enterprises the flexibility to integrate what works, govern at scale, and modernize on their own terms, without the need to rip and replace. We’re meeting them where they are and helping them move forward with confidence.”

YugabyteDB adds support for Postgres extension DocumentDB

DocumentDB is an open source NoSQL database created by Microsoft to offer a Postgres-based standard for BSON data types. 

According to Yugabyte, adding NoSQL workloads into YugabyteDB provides developers with more database flexibility and cuts down on database sprawl. 

“Although developers use MongoDB for NoSQL document database needs, it is not open source and presents many users with vendor lock-in issues,” said Karthik Ranganathan, co-founder and CEO of Yugabyte. “Enterprises are looking for a single multi-cloud, vendor-agnostic solution, based on open standards, that can meet their SQL and NoSQL requirements. The icing on the cake is that it is based on Postgres, the fastest growing database in terms of adoption. That’s what we’re providing with the Postgres extension to support document data and operations.”

Azul and JetBrains announce partnership to improve Kotlin runtime performance

Together the companies hope to find ways to improve runtime performance, combining Azul’s JVM expertise with Kotlin’s ability to control bytecode generation. 

“On the Kotlin team, we pay close attention to performance, offering language features such as inline functions and classes, optimizations in the standard library, thoughtful bytecode generation, and the Kotlin coroutines library, among other initiatives. A significant contribution to runtime performance comes from the JDK. We believe that viewing these components as an integrated system can bring even greater performance benefits,” JetBrains wrote in a blog post. 

Posted on mongodb google news. Visit mongodb google news

MongoDB (MDB) ended the recent trading session at $188.94, demonstrating a -0.04% swing from the preceding day’s closing price. This change was narrower than the S&P 500’s daily loss of 0.39%. At the same time, the Dow lost 0.27%, and the tech-heavy Nasdaq lost 0.38%.

Heading into today, shares of the database platform had gained 24.62% over the past month, outpacing the Computer and Technology sector’s gain of 19.26% and the S&P 500’s gain of 13.07% in that time.

The upcoming earnings release of MongoDB will be of great interest to investors. In that report, analysts expect MongoDB to post earnings of $0.65 per share. This would mark year-over-year growth of 27.45%. Meanwhile, our latest consensus estimate is calling for revenue of $526.72 million, up 16.9% from the prior-year quarter.

MDB’s full-year Zacks Consensus Estimates are calling for earnings of $2.56 per share and revenue of $2.26 billion. These results would represent year-over-year changes of -30.05% and +12.48%, respectively.

It is also important to note the recent changes to analyst estimates for MongoDB. Recent revisions tend to reflect the latest near-term business trends. Hence, positive alterations in estimates signify analyst optimism regarding the company’s business and profitability.

Based on our research, we believe these estimate revisions are directly related to near-team stock moves. To exploit this, we’ve formed the Zacks Rank, a quantitative model that includes these estimate changes and presents a viable rating system.

Ranging from #1 (Strong Buy) to #5 (Strong Sell), the Zacks Rank system has a proven, outside-audited track record of outperformance, with #1 stocks returning an average of +25% annually since 1988. The Zacks Consensus EPS estimate has moved 0.18% lower within the past month. As of now, MongoDB holds a Zacks Rank of #3 (Hold).

In terms of valuation, MongoDB is currently trading at a Forward P/E ratio of 73.98. This indicates a premium in contrast to its industry’s Forward P/E of 28.98.

It is also worth noting that MDB currently has a PEG ratio of 11.72. The PEG ratio is similar to the widely-used P/E ratio, but this metric also takes the company’s expected earnings growth rate into account. The Internet – Software industry had an average PEG ratio of 2.22 as trading concluded yesterday.

The Internet – Software industry is part of the Computer and Technology sector. This industry, currently bearing a Zacks Industry Rank of 73, finds itself in the top 30% echelons of all 250+ industries.

The Zacks Industry Rank gauges the strength of our individual industry groups by measuring the average Zacks Rank of the individual stocks within the groups. Our research shows that the top 50% rated industries outperform the bottom half by a factor of 2 to 1.

Article originally posted on mongodb google news. Visit mongodb google news

Article originally posted on InfoQ. Visit InfoQ

Google’s open-source generative artificial intelligence (AI) model Gemma 3 supports vision-language understanding, long context handling, and improved multi-linguality. In a recent blog post, Google DeepMind and AI Studio teams discussed the new features in Gemma 3. The model also highlights KV-cache memory reduction, a new tokenizer and offers better performance and higher resolution vision encoders.

Gemma 3 Technical Report summarizes these new features and capabilities. The new vision-language understanding capability includes the models (4B, 12B and 27B parameters) using a custom Sigmoid loss for Language-Image Pre-training (SigLIP) vision encoder, which enables the models to interpret visual input. The encoder operates on fixed 896×896 square images and to handle the images with different aspect ratios or high resolutions, a “Pan & Scan” algorithm is employed. This involves adaptively cropping the image, resizing each crop to 896×896, and then encoding it. The Pan & Scan method further improves performance on tasks involving non-square aspect ratios, high-resolution images, and text reading in images. The new model also treats images as a sequence of compact “soft tokens” produced by MultiModalProjector. This technique cuts down on the inference resources needed for image processing by representing visual data with a fixed number of 256 vectors.

The vision encoder processing in Gemma 3 uses bi-directional attention with image inputs. Bidirectional attention is a good approach for understanding tasks (as opposed to prediction tasks) where we have the entire text and need to deeply understand it (like in models such as BERT).

Architectural changes for memory efficiency include modifications to reduce KV-cache memory usage, which tends to increase with long context. These changes reduce the memory overhead during inference with long context compared to global-only attention mechanisms used in Gemma 1 and the 1:1 local/global ratio used in Gemma 2. This allows for the analysis of longer documents and conversations without losing context. Specifically, it can handle 32k tokens for the 1B model and 128k tokens for larger models.

Gemma 3 also introduces an improved tokenizer. The vocabulary size has been changed to 262k, but uses the same SentencePiece tokenizer. To avoid errors, they recomend to use the new tokenizer with Gemma 3. This is the same tokenizer as Gemini which is more balanced for non-English languages. Gemma 3 has improved multilingual capabilities due to a revisited data mixture with an increased amount of multilingual data (both monolingual and parallel). The team also revised the pre-training data mixture and post-training process to enhance its multilingual capabilities.

Gemma 3 models showed better performance compared to Gemma 2 on both pre-trained instruction-tuned versions across various benchmarks. It is a better model that fits in a single consumer GPU or TPU host. The Gemma 27B IT model ranks among the top 10 models in LM Arena as of Apr 12, 2025, outperforming much larger open models and showing a significantly higher Elo score than Gemma 2.

Gemma 3 models’ longer context handling can generalize to 128k context length after Rotary Position Embedding (RoPE) rescaling during pre-training. They increased RoPE base frequency from 10k to 1M on global self-attention layers, and kept the frequency of local layers at 10k.

For more information on Gemma 3 model, check out the developer guide, model card, meme generator, and Gemmaverse to explore Gemma models developed by the community.

Posted on mongodb google news. Visit mongodb google news

Article originally posted on mongodb google news. Visit mongodb google news

Posted on mongodb google news. Visit mongodb google news

Key Takeaways:

• Loop Capital downgrades MongoDB from Buy to Hold, highlighting integration concerns.
• Analyst consensus shows a significant potential upside for MongoDB shares.
• GuruFocus estimates a 132.81% upside based on its GF Value calculation.

In a recent shift, Loop Capital has adjusted its stance on MongoDB (MDB, Financial), downgrading the stock from Buy to Hold while cutting the price target significantly to $190 from its previous $350. Analyst Yun Kim points to slower-than-expected integration of AI technologies and challenges in the adoption of the Atlas platform as critical factors that may hinder substantial growth, particularly among large-scale enterprise clients.

Wall Street Analysts’ Insights

The broader analyst community maintains a positive outlook for MongoDB. According to the evaluations provided by 34 analysts over the next year, the average target price for MongoDB Inc (MDB, Financial) stands at $273.14. This forecast includes a high estimate reaching $520.00 and a lower marker at $160.00. The average price target denotes a notable 44.99% upside from the current share price of $188.39. Further insights and detailed data can be accessed through the MongoDB Inc (MDB) Forecast page.

The overall sentiment among 37 brokerage firms aligns with an “Outperform” rating for MongoDB, reflected in an average brokerage recommendation score of 2.0 on a scale where 1 represents a Strong Buy and 5 indicates a Sell.

Exploring GuruFocus’ GF Value Estimate

Utilizing comprehensive evaluation metrics, GuruFocus estimates MongoDB’s GF Value at $438.57 in the next year, which signifies a potential upside of 132.81% from the current price point of $188.385. The GF Value is an insightful metric representing the fair trading value of the stock, calculated based on historical trading multiples, past business growth, and future business performance projections. Investors interested in a more detailed assessment can explore the data available on the MongoDB Inc (MDB, Financial) Summary page.

Article originally posted on mongodb google news. Visit mongodb google news

Posted on mongodb google news. Visit mongodb google news

00:00 Speaker A

Now time for some of today’s trending tickers. We’re watching Levi Strauss, Hewlett Packard, and Mongo DB. First up, Levi Strauss has agreed to sell Docker to brand management firm Authentic Brands Group for initial value of $311 million. The denim company said in October that it was exploring a potential sale of the Dockers brand, all part of its strategy to focus on its core Levi’s label and expand its direct to consumer business. The transaction is expected to close on or around July 31st for some of the property. Next, Hewlett Packard, getting an upgrade to outperform from in line at Evercore ISI. The analyst saying the risk reward is fairly attractive, specifically for investors who have some duration. The analyst highlighted four key scenarios for HPE when it comes to approval for the long awaited Juniper deal. The firm thinks their upside scenario is more likely, in which case the stock would be worth between 25 to 30 bucks a share. And even without approval for the Juniper deal, Evercore says the company has ways to improve profits. Finally, Mongo DB, cut to hold from buy at Loop Capital Markets. The firm saying the company’s cloud platform, Atlas, isn’t gaining traction as quickly as expected, which could lead to slower AI project growth on the platform. The analyst expects consumption growth to continue to decelerate until the company makes progress on its larger enterprise customers. As a result, the firm slashed its price target on shares to $190. That’s down significantly from the prior $350. You can scan the QR code below to track the best and worst performing stocks of the session with Yahoo Finance’s trending tickers page.

Article originally posted on mongodb google news. Visit mongodb google news

Posted on mongodb google news. Visit mongodb google news

The most oversold stocks in the consumer discretionary sector presents an opportunity to buy into undervalued companies. The RSI is a momentum indicator, which compares a stock’s strength on days when prices go up to its strength on days when prices go down. When compared to a stock’s price action, it can give traders a better sense of how a stock may perform in the short term. An asset is typically considered oversold when the RSI is below 30 , according to Benzinga Pro . Here’s the latest list of major oversold players in this sector, having an RSI near or below 30. Sweetgreen Inc (NYSE: SG ) On May 8, Sweetgreen reported first-quarter results and cut its FY25 sales guidance below estimates. “Sweetgreen’s first quarter results demonstrate the strength and adaptability of our operating model. In the face of a challenging industry landscape, we stayed true to our mission, driving innovation and elevating the guest experience,” said Jonathan Neman, Co-Founder and Chief Executive Officer. “We believe the strength of our brand, our deep focus on the customer, and commitment to delivering a meaningful value proposition positions Sweetgreen well to navigate the current environment.” The company’s stock fell around 16%

Article originally posted on mongodb google news. Visit mongodb google news

Posted on mongodb google news. Visit mongodb google news

Investing.com — Loop Capital downgraded MongoDB (NASDAQ:MDB) to Hold from Buy and slashed its price target to $190 from $350 in a note Tuesday.

Article originally posted on mongodb google news. Visit mongodb google news