while doing QA testing on a BSP (Board Support Package) for an embedded Linux board (RSB-3720/AOM-2721) and facing several issues during the testing process.
I need full information for the QA process of the same.
I was looking for an answer to this for a few hours and had a hard time. For anyone else looking at this:
If your app is published on the App Store, then you do not need to track which version of a manifest a user is currently on. This is because the installed app is updated for all users within a few hours of any new manifest upload being approved. There will not be multiple versions of the app in deployment, only the most recent (and perhaps some instances of the version before most recent).
So, for backwards compatibility, so long as you maintain backwards compatibility of your backend for 48 hours, then you should be in the clear with regards to supporting users through a new version release. Just upload the new version, and all your users will be moved onto that. I'm using 48 hours here to be roughly-safe, as documentation says the update should occur within a few hours.
nagamanoj, I understand that for your case, you were changing bot commands. For existing commands you can blue-green the new functionality in the backend. For new commands, all users will be able to use those as soon as they're released, there's not a good way to blue-green those. You'd rather ensure the functionality is robustly tested via another approach before the app update is released.
Found a similar issue while calling Prometheus API from Java. Followed @Sotirios Delimanolis. It is working now. Below is the sample code to get CPU metric from Prometheus.
and it created uz_CYrl folder inside locale folder, it works in Windows and Mac locally but in docker-compose running project returns uz translation instead of uz-cyrl always.
When I execute makemessages command inside container and it raise different
invalid locale uz-cyrl, did you mean uz_Cyrl?
So I changed folder name from uz_CYrl to uz_Cyrl and it works both local and through docker-compose also.
So I understand that uz-cyrl translation .po and .mo files should be inside uz_Cyrl folder not uz_CYrl.
It sounds like your POS session opening and closing times are being stored or displayed with an incorrect offset, even though the container timezones are correct. This could be due to:
Timezone conversion issues in Odoo (if you're using Odoo)
Database storing UTC while UI displays local time incorrectly
Misconfigured user timezone settings
If you want to fix this manually via a Server Action without reinstalling everything, you can write an Odoo server action in Python to adjust the session times. Here's how you can do it:
Steps to Fix via Server Action
Navigate to:
Settings > Technical > Actions > Server Actions
Create a New Server Action
Model: POS Session (pos.session)
Action Type: Execute Python Code
Use this Python script in the server action:
Select the affected records
Run the Server Action manually
Alternative: Prompt User for Input (Manual Adjustment)
If you want to manually enter the correct date, you need to trigger a wizard (popup) instead of a direct Server Action. However, Odoo Server Actions do not support interactive input boxes directly. You'd need to create a custom module with a wizard (TransientModel) that allows user input before applying changes.
As mentioned on the Rust discord, you are not parsing the svix-signature header to compare the actual signatures. There is additional metadata in the header.
Also please note that you should use constant-time comparison functions for verifying the hash to prevent timing attacks.
Sure! Below are the answers to the short and long questions covering the Design and Analysis of Algorithms.
Short Answer Questions
Module 1: Analysis of Algorithms
Define an algorithm.
An algorithm is a finite sequence of well-defined instructions or steps designed to perform a specific task or solve a particular problem.
What are the characteristics of a good algorithm?
A good algorithm should be clear and unambiguous, efficient in terms of time and space, correct, and should terminate after a finite number of steps.
What is time complexity?
Time complexity is a computational complexity that describes the amount of time an algorithm takes to complete as a function of the length of the input.
Define asymptotic notations: ( O ), ( \Omega ), and ( \Theta ).
( O ) (Big O) notation describes an upper bound on the time complexity, representing the worst-case scenario.
( \Omega ) (Big Omega) notation describes a lower bound, representing the best-case scenario.
( \Theta ) (Big Theta) notation describes a tight bound, indicating that the function grows at the same rate in both upper and lower bounds.
What is the difference between best-case, average-case, and worst-case complexities?
Best-case complexity refers to the minimum time an algorithm takes for the most favorable input, average-case complexity is the expected time for a random input, and worst-case complexity is the maximum time taken for the least favorable input.
Explain time-space trade-offs in algorithms.
Time-space trade-offs occur when an algorithm uses more memory to reduce the time complexity or vice versa. For example, caching results can speed up computations at the cost of additional memory usage.
What is a recurrence relation in algorithm analysis?
A recurrence relation is an equation that recursively defines a sequence of values, often used to express the time complexity of recursive algorithms.
State the Master’s theorem.
The Master’s theorem provides a method for analyzing the time complexity of divide-and-conquer algorithms that fit the form ( T(n) = aT(n/b) + f(n) ), where ( a \geq 1 ) and ( b > 1 ).
Solve the recurrence relation ( T(n) = 2T(n/2) + n ) using the Master’s theorem.
Here, ( a = 2 ), ( b = 2 ), and ( f(n) = n ). Since ( f(n) ) is ( \Theta(n^{\log_b a}) = \Theta(n) ), we can apply case 2 of the Master’s theorem, which gives us ( T(n) = \Theta(n \log n) ).
What is the significance of Big-O notation in algorithm analysis?
Big-O notation provides a high-level understanding of the algorithm's efficiency by describing its upper limit on time or space requirements, allowing for comparison between different algorithms.
Differentiate between polynomial time and exponential time algorithms.
Polynomial time algorithms have a time complexity of ( O(n^k) ) for some constant ( k ), while exponential time algorithms have a time complexity of ( O(2^n) ) or similar, which grows much faster than polynomial time as ( n ) increases.
Give an example of an algorithm with ( O(n \log n) ) complexity.
Merge Sort is an example of an algorithm with ( O(n \log n) ) complexity due to its divide-and-conquer approach.
Why is Merge Sort more efficient than Bubble Sort?
Merge Sort has a time complexity of ( O(n \log n) ), while Bubble Sort has a time complexity of ( O(n^2) ). Merge Sort efficiently divides the array and merges sorted subarrays, while Bubble Sort repeatedly compares adjacent elements, making it less efficient for large datasets.
What is the importance of performance measurement in algorithms?
Performance measurement helps in evaluating the efficiency of algorithms, allowing developers to choose the most suitable algorithm for a given problem based on time and space requirements.
Define recursive and iterative algorithms.
Recursive algorithms solve problems by calling themselves with smaller inputs, while iterative algorithms use loops to repeat a set of instructions until a condition is met.
Module 2: Fundamental Algorithmic Strategies
What is brute-force technique? Give an example.
The brute-force technique involves trying all possible solutions to find the correct one. An example is the brute-force search for a password by trying every possible combination.
Explain the greedy approach with an example.
The greedy approach builds a solution piece by piece, always choosing the next piece that offers the most immediate benefit. An example is the coin change problem, where the algorithm selects the largest denomination coin first.
What is dynamic programming? How is it different from divide-and-conquer?
Dynamic programming is an optimization technique that solves problems by breaking them down into simpler subproblems and storing their solutions to avoid redundant calculations. It differs from divide-and-conquer, which solves subproblems independently without storing their solutions.
State the principle of optimality in dynamic programming.
The principle of optimality states that an optimal solution to any instance of an optimization problem is composed of optimal solutions to its subproblems.
What is backtracking? Give an example.
Backtracking is a problem-solving technique that incrementally builds candidates for solutions and abandons a candidate as soon as it is determined that it cannot lead to a valid solution. An example is solving the N-Queens problem.
Explain the branch-and-bound technique.
Branch-and-bound is an algorithm design paradigm for solving combinatorial optimization problems. It systematically explores branches of a solution space and uses bounds to eliminate branches that cannot yield better solutions than the best found so far.
What is the difference between backtracking and branch-and-bound?
Backtracking explores all possible solutions and abandons those that fail to satisfy constraints, while branch-and-bound uses bounds to prune branches of the search space, potentially reducing the number of solutions explored.
Describe the 0/1 Knapsack problem.
The 0/1 Knapsack problem involves selecting items with given weights and values to maximize the total value in a knapsack of limited capacity, where each item can either be included or excluded (not partially).
What is the Fractional Knapsack problem? How is it solved?
The Fractional Knapsack problem allows items to be broken into fractions, enabling the selection of portions of items to maximize value within the knapsack's capacity. It is solved using a greedy approach, where items are sorted by their value-to-weight ratio, and the algorithm fills the knapsack with the highest ratio items until the capacity is reached.
Define the Travelling Salesman Problem (TSP).
The Travelling Salesman Problem is a classic optimization problem where the objective is to find the shortest possible route that visits a set of cities exactly once and returns to the origin city.
What is the difference between Prim’s and Kruskal’s algorithms?
Prim’s algorithm builds a minimum spanning tree by starting from a single vertex and adding the smallest edge connecting a vertex in the tree to a vertex outside the tree. In contrast, Kruskal’s algorithm sorts all edges and adds them one by one to the tree, ensuring no cycles are formed.
State the steps of Dijkstra’s algorithm.
Dijkstra’s algorithm involves initializing distances from the source to all vertices as infinite, setting the distance to the source as zero, and repeatedly selecting the vertex with the smallest distance, updating the distances of its neighbors until all vertices are processed.
What is the difference between BFS and DFS in graph algorithms?
Breadth-First Search (BFS) explores all neighbors at the present depth prior to moving on to nodes at the next depth level, while Depth-First Search (DFS) explores as far as possible along a branch before backtracking. BFS uses a queue, whereas DFS uses a stack.
How does the First-Fit algorithm work in Bin Packing?
The First-Fit algorithm places each item into the first bin that has enough remaining capacity to accommodate it, continuing until all items are placed.
What are NP-hard and NP-complete problems?
NP-hard problems are at least as hard as the hardest problems in NP, meaning they cannot be solved in polynomial time. NP-complete problems are those that are both in NP and NP-hard, indicating that if any NP-complete problem can be solved in polynomial time, all problems in NP can be solved in polynomial time.
Long Answer Questions
Module 1: Analysis of Algorithms
Explain the characteristics of an algorithm with examples.
A good algorithm should be clear, efficient, and correct. For instance, the Euclidean algorithm for finding the greatest common divisor (GCD) is clear in its steps, efficient with a time complexity of ( O(\log(\min(a, b))) ), and always produces the correct result.
Discuss the three asymptotic bounds: best-case, average-case, and worst-case.
Best-case complexity represents the scenario where the algorithm performs the least number of operations, average-case considers the expected number of operations across all inputs, and worst-case complexity indicates the maximum number of operations required for the least favorable input.
Describe time complexity and space complexity with examples.
Time complexity measures the time an algorithm takes to complete based on input size, such as ( O(n^2) ) for bubble sort. Space complexity measures the memory required, like ( O(n) ) for an algorithm that uses an array of size ( n ).
Analyze the performance of an algorithm using asymptotic notation.
Analyzing performance involves determining the upper and lower bounds of an algorithm's running time. For example, quicksort has an average-case time complexity of ( O(n \log n) ) and a worst-case of ( O(n^2) ).
Explain time-space trade-offs in algorithm design.
Time-space trade-offs involve balancing the use of time and memory. For example, using a hash table can speed up search operations (time efficiency) at the cost of increased memory usage.
Discuss different methods to solve recurrence relations:
Substitution method: Involves guessing a bound and using mathematical induction to prove it.
Recursion tree method: Visualizes the recurrence as a tree and sums the costs at each level.
Master’s theorem: Provides a direct way to analyze recurrences of the form ( T(n) = aT(n/b) + f(n) ).
Solve the recurrence relation ( T(n) = 3T(n/2) + n ) using the recursion tree method.
The recursion tree shows that at each level, the cost is ( n ), and the number of levels is ( \log_2(n) ). Thus, the total cost is ( n \log_2(n) ), leading to ( T(n) = O(n \log n) ).
Compare Divide-and-Conquer and Dynamic Programming approaches.
Divide-and-Conquer breaks a problem into independent subproblems, solving each recursively, while Dynamic Programming solves overlapping subproblems by storing their solutions to avoid redundant calculations. For example, Merge Sort uses Divide-and-Conquer, while the Fibonacci sequence can be efficiently computed using Dynamic Programming.
Explain the working of Merge Sort and derive its time complexity.
Merge Sort divides the array into two halves, recursively sorts each half, and then merges the sorted halves. The time complexity is derived from the recurrence relation ( T(n) = 2T(n/2) + O(n) ), which resolves to ( O(n \log n) ) using the Master’s theorem.
Discuss the importance of algorithmic efficiency in computing.
Algorithmic efficiency is crucial as it directly impacts the performance of software applications. Efficient algorithms can handle larger datasets and reduce resource consumption, leading to faster execution times and better user experiences.
Module 2: Fundamental Algorithmic Strategies
Describe the brute-force approach and its applications.
The brute-force approach systematically enumerates all possible solutions to find the optimal one. It is commonly used in problems like the Traveling Salesman Problem, where all possible routes are evaluated to find the shortest one.
Explain the Greedy approach and solve the Fractional Knapsack problem using it.
The Greedy approach selects the best option available at each step. For the Fractional Knapsack problem, items are sorted by their value-to-weight ratio, and the algorithm fills the knapsack with the highest ratio items until the capacity is reached, allowing for fractional items.
Solve the 0/1 Knapsack problem using Dynamic Programming.
The 0/1 Knapsack problem can be solved using a DP table where rows represent items and columns represent weights. The table is filled based on whether to include an item or not, leading to the maximum value that can be carried in the knapsack.
Discuss the working of Dijkstra’s algorithm with an example.
Dijkstra’s algorithm finds the shortest path from a source vertex to all other vertices in a weighted graph. Starting from the source, it updates the shortest known distances to neighboring vertices and continues until all vertices are processed. For example, in a graph with vertices A, B, and C, if the shortest path from A to B is 5 and from A to C is 10, the algorithm will first set the distance to B as 5 and C as 10.
Explain the Travelling Salesman Problem and solve it using branch-and-bound.
The Travelling Salesman Problem seeks the shortest route visiting each city once and returning to the origin. Using branch-and-bound, the algorithm explores branches of possible routes, calculating lower bounds to prune branches that exceed the current best solution, ultimately finding the optimal route.
Describe the backtracking approach and solve the N-Queens problem using it.
Backtracking incrementally builds solutions and abandons those that fail to meet constraints. For the N-Queens problem, the algorithm places queens on a chessboard one row at a time, backtracking when a placement leads to a conflict, until all queens are placed.
Solve the Graph Coloring problem using backtracking.
The Graph Coloring problem involves assigning colors to vertices such that no two adjacent vertices share the same color. Using backtracking, the algorithm tries to color each vertex and backtracks when a conflict arises, ensuring a valid coloring is found.
Discuss the Bin Packing problem and compare First-Fit and Best-Fit algorithms.
The Bin Packing problem aims to pack items into the fewest number of bins. The First-Fit algorithm places each item in the first bin that can accommodate it, while the Best-Fit algorithm places each item in the bin that leaves the least remaining space. Best-Fit often results in fewer bins used but may require more time to find the optimal bin.
Compare BFS and DFS in terms of time complexity and applications.
BFS has a time complexity of ( O(V + E) ) and is used in shortest path algorithms and finding connected components. DFS also has a time complexity of ( O(V + E) ) and is used in topological sorting and pathfinding in mazes. BFS is better for finding the shortest path in unweighted graphs, while DFS is useful for exploring all possible paths.
Explain Prim’s and Kruskal’s algorithms for finding Minimum Spanning Trees (MST).
Prim’s algorithm starts with a single vertex and grows the MST by adding the smallest edge connecting the tree to a new vertex. Kruskal’s algorithm sorts all edges and adds them to the MST, ensuring no cycles are formed. Both algorithms efficiently find the MST but use different strategies.
What are NP-hard and NP-complete problems? Give examples.
NP-hard problems are at least as hard as the hardest problems in NP and cannot be solved in polynomial time. Examples include the Traveling Salesman Problem and the Knapsack Problem. NP-complete problems are those that are both in NP and NP-hard, meaning they can be verified in polynomial time. Examples include the Boolean satisfiability problem (SAT) and the Hamiltonian cycle problem.
Solve the Coin Change Problem using Dynamic Programming.
The Coin Change Problem can be solved using a DP table where each entry represents the minimum number of coins needed to make a certain amount. The algorithm iterates through each coin and updates the table based on previously computed values, ultimately yielding the minimum coins required for the target amount.
Explain Floyd-Warshall’s algorithm for finding shortest paths in a weighted graph.
Floyd-Warshall’s algorithm computes shortest paths between all pairs of vertices in a weighted graph. It uses a dynamic programming approach, iteratively updating the distance matrix by considering each vertex as an intermediate point, ensuring that the shortest paths are found.
Describe the Travelling Salesman Problem and implement an approximation algorithm.
The Travelling Salesman Problem seeks the shortest route visiting each city exactly once. An approximation algorithm, such as the nearest neighbor heuristic, starts at a random city, repeatedly visits the nearest unvisited city, and returns to the starting point, providing a quick, though not necessarily optimal, solution.
Discuss how algorithms impact real-world applications like network routing, AI, and cryptography.
Algorithms play a crucial role in network routing by determining the most efficient paths for data transmission, enhancing speed and reliability. In AI, algorithms enable machine learning models to learn from data, making predictions and decisions. In cryptography, algorithms secure data through encryption and decryption processes, ensuring confidentiality and integrity in communications.
It seems to be happening because PowerShell Export-Excel is creating a 'minimal' Excel file, with no version information. And when your EXCEL opens it it makes some assumptions, and thinking that XLOOKUP can potentially return an array, it makes sure that only the first item is returned (by adding the @). I am not sure how to 'inject' a version number (and make content compatible with that format) into the exported file. Since you do this row by row, why not use VLOOKUP?
Add import keras.api as keras at the end of tensorflow/init.py.
keras.api is the correct module used by tensorflow. By adding this line, keras is explicitly imported rather than lazy-loaded
Based on the current information, I am guessing that there may be a YAML file in your "Staging" branch with the same name as the YAML file used to create the pipeline.
If such a file exists in "Staging" branch, please check whether there is a trigger section in the YAML.
If "Disable implied YAML CI trigger" is not enabled and no trigger section is added in the YAML, then the YAML pipeline is configured by default with a CI trigger on all branches.
You can set trigger to none to disable the CI trigger OR enable "Disable implied YAML CI trigger" settings in your project settings.
If there is trigger session and "Staging" branch is a trigger branch, please remove it.
If there isn't such YAML file in "Staging" branch, please share a screenshot of the build summary page of the CI triggered build. URL format is https://dev.azure.com/{orgName}/{projectName}/_build/results?buildId={buildId}&view=results.
"Too Many Requests" is definitely not the issue. The problem is caused by recent changes in yfinance. If you use Google Colab it does not provide the latest version by default, so you need to upgrade it manually (and better to clean cache):
Normally, main() is called only once and serves as the entry point, it initializes Flutter and starts the app. Once the app starts, main() is not called again unless explicitly restarted.
main() can be called multiple times in 3 cases
1- In Flutter debug mode(during development), when you do a Hot Restart (NOT IN DESKTOP DEV), the app fully restarts and calls main() again.
2- One can explicitly call main() inside the app, I do not recommend for security..multiple instances of the app running in memory..
3- After a Crash
Solutions:
1- for desktop apps try to restarted manually to recall the main().
2- call runApp() multiple times without restarting main(), but it will replace the widget tree
Note - Multiprocessing.py doesn't work in IDLE, you have to use software like intellij or something.
def funct(a, b):
#run .bat file with params (a,b)
if __name__ == "__main__":
# run as many cores as in the range
processes = []
for _ in range(4):
p = multiprocessing.Process(target=funct, args=[2, "hello"])
p.start()
processes.append(p)
for process in processes:
process.join()
The Prepare() method in DialogueManager.cs isn't being called automatically in Dialogue Manager 3.3.2, which may be the problem you're running into. Either edit the DialogueManager.cs script to call it or make it static and call it manually in _Ready(). :-)
Turns out it wasn’t actually hanging—the findOne inside a loop of over 2000 items was just extremely slow. I figured this out by adding mongoose.set("debug", true); after mongoose.connect(), which revealed that Mongoose was making a separate query for each vacancy, causing a massive slowdown.
The fix was simple: instead of querying the database repeatedly, I fetched all existing entries at once using Model.find({}, "vacancyId") and stored them in an array for fast lookups in memory.
This answers the request for concurrency and gap-free unless rollback, which I don't think will ever be necessary assuming the row in the table holding the counter exists. In this example, XASYS6 is the table, COMPANY_NUMBER_ID is the inique key column and NEXT_AVAIL_SOLD_TO_CUSTOMER_NO is the counter.
This is Db2 for i SQL PL, but it should be 100% compatible.
IN @PARMORIG_COMPANY_NUMBER_ID DECIMAL(3,0),
OUT @NEXTAVAILABLESOLDTOCUSTID DECIMAL(10,0)
SELECT NEXT_AVAIL_SOLD_TO_CUSTOMER_NO INTO @NEXTAVAILWORKVAR10
FROM XASYS6 WHERE (
( @PARMORIG_COMPANY_NUMBER_ID = COMPANY_NUMBER_ID ) )
WITH RS ;
UPDATE XASYS6 SET
NEXT_AVAIL_SOLD_TO_CUSTOMER_NO = @NEXTAVAILWORKVAR10 + 1
WHERE (
( @PARMORIG_COMPANY_NUMBER_ID = COMPANY_NUMBER_ID ) ) ;
SET @NEXTAVAILABLESOLDTOCUSTID = @NEXTAVAILWORKVAR10 ;
You might also try substituting the iframe tag with --> an embed tag within your HTML. This worked for me while bypassing the browser errors particularly within Firefox.
Dmn this api is gone. Basically u can get a
client- credentials.json from api console
Allow mail IDs u want to allow.
Use this code for logging in and getting user access token.
If u search u will be able get REST methods to do this as well.
Code- https://github.com/Underemployed/Google-Photos-Downloader/blob/main/Google.py
In case this helps anyone in the future. My issue was that I wasnt on the directory of the root of the project. Make sure you 'cd' to the right directory.
When the -fsanitize=address option is used to link a program, the GCC driver automatically links against libasan. If libasan is available as a shared library, and the -static option is not used, then this links against the shared version of libasan. The -static-libasan option directs the GCC driver to link libasan statically, without necessarily linking other libraries statically.
Reasons:
Blacklisted phrase (1): this link
RegEx Blacklisted phrase (1): I'm getting following error
The gems were installed to the default GEM_HOME directory. This is likely /Library/Ruby/Gems/ on a mac. You can go in there and manually rm -rf the stuff in there without worrying.
I encountered the same issue. The GitHub official repository for VS Code says that building Node.js requires a version higher than 20. You mentioned installing an older version, 18. That doesn't seem right, does it?
These above below are wrong about "This is not pointless or useless" because platforms like steam suffer with cookie session stealing, and this is the only effective solution for now: https://github.com/w3c/webappsec-dbsc/blob/main/README.md
What about ^(([a-z0-9]{4}){2,8})$ since you show in the last example having to support some different multiples of 4, 8 to 32. I used Notepad++ to check my results, hence the other changes in the expression.
Obviously it only works when there is the situation as you explained, all multiples of 4 in the range of 8 to 32.
Use a CTE. This is roughly what it should look like.
with cteParams as
(select explode(split(?, ',')) as MyParamValue)
SELECT DISTINCT
dimpractice.PracticeId,
dimpractice.PracticeName AS Practice
FROM curated.dimprojectmaster
INNER JOIN curated.dimorganization
ON dimprojectmaster.OrganizationID = dimorganization.OrganizationID
INNER JOIN curated.dimpractice
ON dimorganization.PracticeID = dimpractice.PracticeID
INNER JOIN curated.dimprofitcenter
ON dimorganization.ProfitCenterID = dimprofitcenter.ProfitCenterID
INNER JOIN curated.dimoffice
ON dimprofitcenter.OfficeID = dimoffice.OfficeID
AND dimprojectmaster.ChargeType IN ('Regular', 'Promotional')
inner join cteParams on dimoffice.OfficeName = cteParams.MyParamValue
ORDER BY Practice
The group thing works but now i want the if user select one date range lets say for 30 days then the pther date range filter should automatically get filter to same number of days but for previous period.what do i do?
Assuming you know for sure that nobody is intentionally revoking access to this account (e.g. via the my.plaid.com portal), I'd recommend filing a Plaid support ticket including the details you provided -- it doesn't look like there's anything obvious you're doing wrong here, and this could be a symptom of an integration issue between Plaid and the bank.
If u are trying to config docker resource with wsl config file. You need to restart wsl sub-system first; and the best way to restart your wsl sub-system is restart your computer.
There is nothing "virtual" about those tables, they are as real as any other tables and they are called calculated tables and yes, you can create them "on the fly", see Create calculated tables in Power BI Desktop
I was running a docker container in the same port of spring (in my case was the 80), it took a while to me to remember that, maybe can be something related.
Consumer Group in Kafka reads from the same topic but the each message is consumed only by one client among consumer group clients. So, no two client in a consumer group read the same message for the same topic. This is contrary to Kinesis that each client App can read the same message. That's the big difference.
Git has a 10k quota changes on your working directory. This means Git cannot do its thing beyond 10k changes for every commit. When you delete a folder with lots of files, chances are you will reach that quota. For instance, I deleted a series of directories within the main directory which triggered 1,747,391 deletions. I do not know exactly how this translate in terms of Git changes but it was over 10k because of that as shown here:
Then this problem was fixed by itself after 10 commits. In VS Code, if you let your mouse over the commit history item it will show you that information.
This won't fix all your problems, but I found discrepancies in the first three filenames compared to the names of the files downloaded from the site you mentioned. These will cause load or download errors when your code is run.
'Burn The World Waltz.mp3' // Rename the downloaded file to remove the space before .mp3
'Le Grand Chase.mp3' // Removed the e from end of Grand to match download
'Mesmerizing Galaxy Loop.mp3' // Appended " Loop" to match download
activity Write a program in Java that will ask the user
to input temperature in celsus and then
theprogram will find the Fahrenheit. Formula is
9/5*t emp+32
(Feb 20, 2025) We just ran into this with Anaconda; in particular, its most recent geopandas is 0.14.2, which when selected for installation, automatically installs fiona 1.10 as one of its dependencies. Unfortunately as noted above, this triggers the error. Forcing geopandas to 0.14.4 is possible, but other things broke (including spyder). Things worked ok if you install the most recent geopandas and then separately downgrade the fiona to 1.9.5. (python v is 3.12).
Posting my own answer as I achieved to do what I was looking for (full code).
The transformation code looks like the following:
val usersRdd = sc.parallelize(users)
val ticketsRdd = sc.parallelize(tickets)
val partitioner = new DoubleDenormalizationPartitioner(p)
// Explosion factor as explained in the EDIT of my question.
val usersExplosionFactor = (2 * Math.floor(Math.sqrt(p)) - 1).toInt
val explodedUsers = usersRdd
.flatMap { user =>
(0 until usersExplosionFactor)
.map(targetP => (user, -targetP))
}
// Below we're partitioning each RDD using our custom partitioner (see full code for implementation)
val repartitionedUsers = explodedUsers
.keyBy { case (user, targetP) => (user.id, targetP) }
.partitionBy(partitioner)
val repartitionedTickets = ticketsRdd
.keyBy(ticket => (ticket.assigneeId, ticket.requesterId))
.partitionBy(partitioner)
val denormalizedTickets = repartitionedTickets
.map(_._2)
.zipPartitions(repartitionedUsers.map(_._2._1), preservesPartitioning = true) { case (tickets, usersI) =>
// Here, thanks to the map we can denormalize the assignee and requester at the same time
val users = usersI.map(u => (u.accountId, u.id) -> u.name).toMap
tickets.map { ticket =>
(
ticket,
users.get(ticket.accountId, ticket.assigneeId),
users.get(ticket.accountId, ticket.requesterId)
)
}
}
.mapPartitions(_.map { case (ticket, assignee, requester) =>
(ticket.accountId, ticket.id, assignee, requester)
})
I tested the performance of my solution compared to Dataframe joins and RDD joins, not working so smoothly.
Overall I imagine that the advice "do not use RDDs unless you really what you're doing" applies here (I don't really know what I'm doing here, first time really using the RDDs in an "advanced" way).
I hope it could still help someone or that at least someone found this problem interesting (I did).
since you have set refresh_token as an HTTP-only cookie, it cannot be accessed directly from the frontend. However, your backend should be able to read it from the request.
Possible reasons for the issue:
Cookie Settings: You have httponly=True and secure=False. If your app runs over HTTPS, you need to set secure=True. Also, try changing samesite='Lax' to samesite='None' along with secure=True.
Domain Mismatch: If your backend and frontend run on different domains, you might need to set the cookie with domain="yourdomain.com" in response.set_cookie.
CORS and Cookie Settings: Check your Django settings for SESSION_COOKIE_SAMESITE and CSRF_COOKIE_SAMESITE. Also, ensure that your frontend requests are sent with credentials: "include".
To debug:
Check if the refresh_token is actually set in the browser using Developer Tools (Application -> Cookies).
Log request.COOKIES in your backend using print(request.COOKIES) to see if the cookie is being received.
Try these steps and let me know if the issue persists. We can debug further with additional logs
The pyFGLT package (https://fcdimitr.github.io/pyfglt/) allows you to calculate graphlet degrees for a graph (disclaimer: I am a maintainer in the package).
It is indeed an overly complicated and frustrating setup. I've found some helpful information in the Redhat man page for update-ca-trust which describes the details.
But you may want to consult the version of that man page which comes with the particular distro/version of Linux you are using, as there might be differences.
Error was in the view due to not handling the initial invalid form when this code was first called.
Thanks to @willeM_VanOnsem for pointing out irregularities which allowed me to find the issue and correct.
@login_required(login_url="/login")
def user_profile_admin(request):
if request.method == "POST":
user_id = request.POST.get("user_id")
if user_id != None: # this is when edit button pressed in members.html
user_object = User.objects.get(pk=user_id)
email = request.POST.get("email")
if email != None: # this is when the user admin form is actually submitted
user_object = User.objects.get(email=email)
athletes = user_object.athletes.all() #athletes for the user being updated
form = UserAdminForm(request.POST or None, instance=user_object)
if form.is_valid():
user_object = form.save()
success_message="You have updated profile for user : "+email +" successfully"
messages.success(request, success_message)
return redirect('members')
else:
print(form.errors.as_data()) # here you print errors to terminal
user_id = request.POST.get("user_id")
if user_id != None: # this is when edit button pressed in members.html
user_object = User.objects.get(pk=user_id)
print("user id")
email = request.POST.get("email")
if email != None: # this is when the user admin form is actually submitted
user_object = User.objects.get(email=email)
print("email")
form = UserAdminForm(instance=user_object)
return render(request, 'account/user_profile_admin_form.html', {"form": form, "athletes": athletes})
else:
return render(request, 'members')
Well these things are difficult to understand when you don't show any code/pseudo-code. If you can, post the algorithm you implemented.
The design idea you describe does not seem like it is inherently livelocks, it all depends on your actual algorithm and implementation.
Next.js has API routes built in that act like a mini backend, and for many situations, they suffice. But if you look closer, you'll see that it doesn't have some of the flexibility and might of a full-fledged backend like Express.
So, why use Express over Next.js API routes?
Well, Express is a mature backend framework, whereas Next.js API routes are essentially light-weight serverless functions. Here are a couple of things that Express does better:
File Handling:
In Express, you could easily use res.download() to return files and download them. In Next.js API routes, you'd have to do it all manually and set headers yourself.
Middleware & Routing:
Express leaves you entirely in charge of middleware, custom routes, and request handling. Next.js API routes don't offer as much freedom in this sense.
Real-Time Features:
Do you need WebSockets or long-lived connections? Express plays nicely with things like Socket.io, whereas Next.js isn't exactly designed for that.
Scalability & Clean Architecture:
Having your frontend (Next.js) separated from your backend (Express) keeps your project scalable and maintainable in the future.
What's the best way to do it?
Utilize Next.js for SSR, authentication (NextAuth), and frontend logic.
Utilize Express for database operations, file upload, and backend-intensive work.
Have Next.js authenticate and pass the access token to your Express server to securely make API calls.
Awesome, I faced the problem which I did not create a topic from the Kafka side. I directly subscribe or publish messages for them, and it works fine with one replica of the instance. But when having a horizontal scaling, only 1 replica will listen to the event with the below setup error:
KafkaJSProtocolError: This server does not host this topic-partition
type: 'UNKNOWN_TOPIC_OR_PARTITION',
In conclusion, the default partition is 1. if you want to update it you need to create The topic and the partition as the above Code.
Could a leap second have been coded as 2016123123596000+0000 at the start of the last introduced leap second (as per IERS bulletin C 52 of July 6th 2016), for instance used on time.gov reflecting a 60th second ? If not what would be the most accepted format for instance for administrative payment systems ?
I just figured this out today. You have to add a DocumentTransformer -> SecuritySchema using the AddOpenApi options:
Configure Open API
builder.Services.AddOpenApi(o =>
{
o.AddDocumentTransformer((document, _, _) =>
{
document.Components ??= new OpenApiComponents();
document.Components.SecuritySchemes.Add("oauth", new OpenApiSecurityScheme
{
Type = SecuritySchemeType.OAuth2,
Flows = new OpenApiOAuthFlows
{
AuthorizationCode = new OpenApiOAuthFlow
{
AuthorizationUrl = new Uri("<your-app-auth-endpoint>"),
TokenUrl = new Uri("<your-app-token-endpoing>"),
Scopes = new Dictionary<string, string>
{
{"api://<client-id>/data.read", "Read Data"}
}
}
}
});
return Task.CompletedTask;
});
});
You can find the authorize/token endpoints by going to your Entra Admin Center -> Applications -> App Registrations -> (Selecting Your App) -> Endpoints (top banner at the time of writing) and then I used the OAuth 2.0 auth/token endpoints that should look something like:
We had to add a scope for our API app registration as using just User.Read did not work. You can do this by going to your app registration -> Expose an API and then adding a scope that will usually look something like: api://<client-id>/<scope-name>
Once this is all configured, you can spin up the Scalar UI. There should be an Authentication box at the top with an Auth Type dropdown. You can select oauth and then ensure PKCE/Scopes are selected and click Authorize.
Additional Context
We currently have two App Registrations in Entra. One is for our Frontend Angular SPA and the other is for our .NET Web API. The client-id we used was from the API App Registration
Try to use flexGrow instead of flex. When setting styles for the ScrollView, avoid using flex: 1 in the contentContainerStyle.
Instead, use flexGrow: 1.
This allows the content to expand and fill the available space without breaking the scrolling functionality.
At the top of that there is a fixed height (like height: '100%') on the parent component, consider removing it or setting it to a more dynamic value. Fixed heights can restrict the ability of the ScrollView to function properly.
Thank you. This was very helpful. I just did Hbar transaction to EVM with this method and back by converting Hbar Account ID into EVM, this is beautiful.
When does Promise resolve/reject actually add a micro task?
Basically immediately at resolve or rejection - but ... it is asyncronous.
Note: The way you formulated that question shows me, that you are aware of being added to the micro task queue not being equal to execution...
...the event loop feeds tasks into the call stack only if it is empty of all synchronous calls, and prioritises micro tasks (promises) over tasks (web api etc.).
await blends into your synchronous, liniar code. The promise must be fulfilled in order for the await code to be executed. It literally means await the fulfillment of the promise before you execute.
To Support Distributed Arch
Redis Cluster Divides itself in ~16K hashslots, and each nodes carries a range of hashslots, To Perform operations like WATCH, MGET the Keys should belong to same HashSlot
This Issue will not occur with Standalone Redis Node
But with Redis Cluster, try to do WATCH, MGET with keys belonging to same hashslot
go to your virtual box machine
configuration -> network -> advanced
disable the Bridged Adapter (for different adapters in network section)
click ok
go back and enable them again
