npm create @bigcommerce/catalyst@latest

 

/**
Checks whether a class exists in an element
*/
function getClass(element, className) {
    return element.className.indexOf(className) !== -1;
  }




//alterntively use
function getClass(element, className) {
    return compareDrawer.className.indexOf("myClass) > -1
  }


// modern use
function hasClass(element, className) {
    return element.classList.contains(className);
}
  
 // returns boolean on all three instances

class Player {
    private int health = 100;

    public void takeDamage(int damage) {
        health -= damage;
        if (health <= 0) {
            die();
        }
    }

    private void die() {
        System.out.println("Player has died.");
        // Additional death logic
    }
}
Example: Score System
java
Copier le code
class Game {
    private int score = 0;

    public void increaseScore(int points) {
        score += points;
        System.out.println("Score: " + score);
    }
}
Example: Power-Ups
java
Copier le code
class PowerUp {
    public void applyTo(Player player) {
        player.increaseSpeed();
    }
}

class Player {
    private int speed = 5;

    public void increaseSpeed() {
        speed += 2;
    }

    public void pickUpPowerUp(PowerUp powerUp) {
        powerUp.applyTo(this);
    }
}
Example: Collectibles
java
Copier le code
class Player {
    private List<Item> inventory = new ArrayList<>();
    private int score = 0;

    public void collect(Item item) {
        inventory.add(item);
        score += item.getPoints();
    }
}

class Item {
    private int points;

    public int getPoints() {
        return points;
    }
}
Example: Level System
java
Copier le code
class Game {
    private List<Level> levels;
    private Level currentLevel;

    public void loadLevel(int levelNumber) {
        currentLevel = levels.get(levelNumber);
    }
}
Example: Particle Effects
java
Copier le code
class Game {
    private List<Particle> particles = new ArrayList<>();

    public void createExplosion(int x, int y) {
        particles.add(new Explosion(x, y));
    }
}

class Particle {
    // Particle implementation
}

class Explosion extends Particle {
    public Explosion(int x, int y) {
        // Explosion effect implementation
    }
}
Example: Sound Effects
java
Copier le code
class SoundManager {
    public static void playSound(String soundFile) {
        // Play sound implementation
    }
}
Example: Background Music
java
Copier le code
class MusicManager {
    public static void playBackgroundMusic(String musicFile) {
        // Play background music implementation
    }
}
Example: Saving/Loading
java
Copier le code
class SaveManager {
    public void save(GameState gameState, String saveFile) {
        // Save game state implementation
    }

    public GameState load(String saveFile) {
        // Load game state implementation
        return new GameState();
    }
}

class GameState {
    // Game state implementation
}
Example: Multiplayer
java
Copier le code
class Game {
    private List<Player> players = new ArrayList<>();

    public void addPlayer(Player player) {
        players.add(player);
    }
}
Example: Inventory System
java
Copier le code
class Player {
    private List<Item> inventory = new ArrayList<>();

    public void addItemToInventory(Item item) {
        inventory.add(item);
    }
}
Example: Dialog System
java
Copier le code
class DialogBox {
    public void show(String text) {
        // Display dialog implementation
    }
}
Example: Pathfinding
java
Copier le code
class PathFinder {
    public List<Point> find(int startX, int startY, int targetX, int targetY) {
        // Pathfinding algorithm implementation
        return new ArrayList<>();
    }
}
Example: Animations
java
Copier le code
class AnimatedSprite {
    private int currentFrame = 0;
    private Image[] animationFrames;

    public void animate() {
        currentFrame = (currentFrame + 1) % animationFrames.length;
    }
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Game extends JPanel implements Runnable, KeyListener {
    private boolean running = true;
    private Player player;
    private Enemy enemy;
    private Thread gameThread;

    public Game() {
        player = new Player();
        enemy = new Enemy();
        this.addKeyListener(this);
        this.setFocusable(true);
        this.setFocusTraversalKeysEnabled(false);
        gameThread = new Thread(this);
        gameThread.start();
    }

    @Override
    public void run() {
        while (running) {
            update();
            repaint();
            try {
                Thread.sleep(16); // roughly 60 FPS
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void update() {
        player.update();
        enemy.update();
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        player.render(g);
        enemy.render(g);
    }

    @Override
    public void keyPressed(KeyEvent e) {
        player.keyPressed(e);
    }

    @Override
    public void keyReleased(KeyEvent e) {
        player.keyReleased(e);
    }

    @Override
    public void keyTyped(KeyEvent e) {}

    public static void main(String[] args) {
        JFrame frame = new JFrame("2D Game");
        Game game = new Game();
        frame.add(game);
        frame.setSize(800, 600);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

class Player {
    private int x, y, velocityY;
    private boolean onGround = true, movingLeft = false, movingRight = false, jumping = false;
    private final int speed = 5, jumpStrength = 10, gravity = 1;

    public void update() {
        if (movingLeft) x -= speed;
        if (movingRight) x += speed;
        if (jumping && onGround) {
            velocityY = -jumpStrength;
            onGround = false;
        }
        y += velocityY;
        if (y >= 500) { // Assuming ground level is at y = 500
            y = 500;
            onGround = true;
            velocityY = 0;
        } else {
            velocityY += gravity;
        }
    }

    public void render(Graphics g) {
        g.fillRect(x, y, 50, 50); // Draw player as a rectangle
    }

    public void keyPressed(KeyEvent e) {
        int key = e.getKeyCode();
        if (key == KeyEvent.VK_LEFT) movingLeft = true;
        if (key == KeyEvent.VK_RIGHT) movingRight = true;
        if (key == KeyEvent.VK_SPACE) jumping = true;
    }

    public void keyReleased(KeyEvent e) {
        int key = e.getKeyCode();
        if (key == KeyEvent.VK_LEFT) movingLeft = false;
        if (key == KeyEvent.VK_RIGHT) movingRight = false;
        if (key == KeyEvent.VK_SPACE) jumping = false;
    }
}

class Enemy {
    private int x, y;

    public void update() {
        // Enemy AI logic
    }

    public void render(Graphics g) {
        g.fillRect(x, y, 50, 50); // Draw enemy as a rectangle
    }
}

INPUT_FILE=$(gsutil ls "gs://atarg-data-dev-smp-extract/atarg_customer_exports/vici_dnbipr_testing/20240601/" | tail -1)
echo $INPUT_FILE
if [[ $INPUT_FILE == gs://* ]]; then
  echo "Compressed File exists"
else
  echo "Compressed file does not exist"
  exit 1
fi
gsutil -q stat gs://atarg-data-dev-smp-extract/atarg_customer_exports/vici_dnbipr_testing_output20/jobid

status=$?
echo $status


if [[ $status != 0 ]]
then
    # clean up anything already in output
    # echo $(gsutil -m rm -r -f {output} 2>&1)
    # python nparts.py --input_prefix gs://atarg-data-dev-smp-extract/atarg_customer_exports2222/vici_dnbipr_testing/20240601/data.000000000000.csv.gz --output_prefix gs://atarg-data-dev-smp-extract/atarg_customer_exports/vici_dnbipr_testing_output20/20240601/ \
    # --region us-central1 --project atarg-data-dev --runner DataflowRunner --job_name testpasrtwswe --temp_location gs://atarg-data-dev-smp-extract/dataflow/tmp31/ &
    tmp_file=$(mktemp) || echo Running  > $tmp_file
    gsutil cp $tmp_file  gs://atarg-data-dev-smp-extract/atarg_customer_exports/vici_dnbipr_testing_output20/jobid || rm "$tmp_file"
    echo submitted job
    # exit 1 means, we'll retry and check status of job
    exit 1
fi

state=$(gcloud dataflow jobs list | grep testpasrtwswe | head -1 | awk '{print $(NF-1)}')
echo $state
echo job state: $state

if [[ $state == "Failed" ]]
then
    gsutil -m rm -r -f gs://atarg-data-dev-smp-extract/atarg_customer_exports/vici_dnbipr_testing_output20/jobid
    exit 1
fi

if [[ $state == "Done" ]]
then
    tmp_file=$(mktemp) || echo "Done"  > $tmp_file
    gsutil cp $tmp_file  gs://atarg-data-dev-smp-extract/atarg_customer_exports/vici_dnbipr_testing_output20/jobid || rm "$tmp_file"
fi

/**
*@description        :This methode useful for to assign permission set group to the user
*@author             : Gopi
*@group              : 
*@created on         : 
*@last modified on   :
*@last modified by   : 
*@modification log   : 
**/ 
@future
    public static void assignPermissionSetGroupToUser(Id userId) {
        try{
            PermissionSetGroup psGroup = [SELECT Id FROM PermissionSetGroup WHERE DeveloperName = 'PortalAuth_User_Permission_Set_Group' LIMIT 1];
            
            if (psGroup != null) {
                system.debug('psGroup==>'+psGroup);
                system.debug('userId==>'+userId);
                PermissionSetAssignment psAssignment = new PermissionSetAssignment();
                psAssignment.AssigneeId = userId;
                psAssignment.PermissionSetGroupId = psGroup.Id;
                insert psAssignment;
                System.debug('Permission Set Group Assignment: ' + psAssignment);
            } else {
                System.debug('Permission Set Group not found.');
                
            }
        }catch(Exception a){
            CustomException__c ex=new CustomException__c();
            ex.ClassName__c='AccountContactCreationController';
            ex.CreatedById = UserInfo.getUserId();
            //ex.Name = 'Exception Name'; 
            ex.Exception_Message__c = a.getMessage();
            ex.Exception_Type__c = a.getTypeName();
            //ex.Govt_Limit_in_Executing_Code__c = a.getGovtLimit();
            ex.LastModifiedById = UserInfo.getUserId();
            ex.Line_Number__c = a.getLineNumber(); 
            ex.MethodName__c = 'assignPermissionSetGroupToUser'; 
            ex.OwnerId = UserInfo.getUserId();
            // ex.Related_To_Number__c = '12345'; 
            ex.StackTrace__c = a.getStackTraceString();
            
            
            insert ex;
        }
    }

//OrderService
import { HttpHeaders, HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { CartItemViewModel, CartViewModel, Product, WishlistItemViewModel, WishlistViewModel } from '../shared/order';
import { BehaviorSubject, map, Observable } from 'rxjs';

@Injectable({
  providedIn: 'root'
})
export class OrderService {
  private cartItemsCountSource = new BehaviorSubject<number>(0);
  cartItemsCount = this.cartItemsCountSource.asObservable();

  private wishlistItemsCountSource = new BehaviorSubject<number>(0);
  wishlistItemsCount = this.wishlistItemsCountSource.asObservable();
  
  httpOptions = {
    headers: new HttpHeaders({
      'Content-Type': 'application/json'
    })
  };
  
  constructor(private http: HttpClient) {}
  apiUrl: string = "https://localhost:7185/api/Order";

  //navbar count
  updateCartCount(count: number) {
    this.cartItemsCountSource.next(count);
  }

  loadCartItems(): void {
    this.getCartItems().subscribe({
      next: (items) => {
        const totalCount = items.reduce((sum, item) => sum + item.quantity, 0);
        this.updateCartCount(totalCount);
      },
      error: (err) => {
        console.error('Error loading cart items', err);
      }
    });
  }

  updateWishlistCount(count: number) {
    this.wishlistItemsCountSource.next(count);
  }

  loadWishlistItems(): void {
    this.getWishlistItems().subscribe({
      next: (items) => {
        this.updateWishlistCount(items.length);
      },
      error: (err) => {
        console.error('Error loading wishlist items', err);
      }
    });
  }

  //products
  getAllProducts(): Observable<Product[]> {
    return this.http.get<Product[]>(`${this.apiUrl}/GetAllProducts`, this.httpOptions);
  }

  getProductById(product_id: number): Observable<Product> {
    return this.http.get<Product>(`${this.apiUrl}/GetProductById/${product_id}`, this.httpOptions);
  }

  //cart
  getCartItems(): Observable<CartItemViewModel[]> {
    const token = localStorage.getItem('token');
    console.log('Retrieved token from localStorage:', token); 

    const httpOptionsWithAuth = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      })
    };

    return this.http.get<CartItemViewModel[]>(`${this.apiUrl}/GetCart`, httpOptionsWithAuth);
  }

  addToCart(cartViewModel: { product_ID: number; quantity: number; size: string }): Observable<any> {
    const token = localStorage.getItem('token');
    console.log('Retrieved token from localStorage:', token); 

    const httpOptionsWithAuth = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      })
    };

    return this.http.post<any>(`${this.apiUrl}/AddToCart`, cartViewModel, httpOptionsWithAuth);
  }

  updateCart(cartViewModel: CartViewModel): Observable<any> {
    const token = localStorage.getItem('token');
    console.log('Retrieved token from localStorage:', token); 

    const httpOptionsWithAuth = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      })
    };

    return this.http.put<any>(`${this.apiUrl}/UpdateCart`, cartViewModel, httpOptionsWithAuth);
  }

  removeFromCart(productId: number): Observable<any> {
    const token = localStorage.getItem('token');
    const httpOptionsWithAuth = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      })
    };
    return this.http.delete<any>(`${this.apiUrl}/RemoveFromCart/${productId}`, httpOptionsWithAuth);
  }

  //wishlist
  getWishlistItems(): Observable<WishlistItemViewModel[]> {
    const token = localStorage.getItem('token');
    const httpOptionsWithAuth = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      })
    };
    return this.http.get<WishlistItemViewModel[]>(`${this.apiUrl}/GetWishlist`, httpOptionsWithAuth);
  }

  addToWishlist(wishlistViewModel: WishlistViewModel): Observable<any> {
    const token = localStorage.getItem('token');
    const httpOptionsWithAuth = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      })
    };
    return this.http.post<any>(`${this.apiUrl}/AddToWishlist`, wishlistViewModel, httpOptionsWithAuth);
  }

  removeFromWishlist(productId: number): Observable<any> {
    const token = localStorage.getItem('token');
    const httpOptionsWithAuth = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      })
    };
    return this.http.delete<any>(`${this.apiUrl}/RemoveFromWishlist/${productId}`, httpOptionsWithAuth);
  }

  moveFromWishlistToCart(product_ID: number): Observable<any> {
    const token = localStorage.getItem('token');
    const httpOptionsWithAuth = {
      headers: new HttpHeaders({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      }),
      responseType: 'text' as 'json' // Specify response type as text
    };
    return this.http.post<any>(`${this.apiUrl}/MoveFromWishlistToCart`, { product_ID, quantity: 1 }, httpOptionsWithAuth);
  }

  //payfast
  getTotalAmount(): Observable<number> {
    return this.getCartItems().pipe(
      map(items => items.reduce((sum, item) => sum + (item.unit_Price * item.quantity), 0))
    );
  }

  getUserData(): any {
    // Replace this with your actual implementation to get user data
    return {
      email: 'user@example.com'
    };
  }
}

/

<script runat="server">
    Platform.Load("Core", "1");

    // Define Data Extension Names
    var sourceDEName = "Kp_Testing";
    var targetDEName = "Processed_Products";

    // Retrieve Source Data Extension
    var sourceDE = DataExtension.Init(sourceDEName);
    var rows = sourceDE.Rows.Retrieve();

    // Retrieve Target Data Extension
    var targetDE = DataExtension.Init(targetDEName);

    // Loop through each row in the source Data Extension
    for (var i = 0; i < rows.length; i++) {
        var sKey = rows[i].SKey;
        var productID = rows[i].ProductID;
        
        // Split ProductID by comma
        var productValues = productID.split(',');

        // Loop through each product value and insert into the target Data Extension
        for (var j = 0; j < productValues.length; j++) {
            var productValue = productValues[j].trim();  // Trim whitespace

            // Insert each product value into the target Data Extension
            targetDE.Rows.Add({ 
                SKey: sKey, 
                ProductValue: productValue 
            });
        }
    }
</script>

SELECT Id,DeveloperName, CreatedDate, CreatedBy.Name, LastModifiedBy.Name FROM FlowDefinition WHERE DeveloperName LIKE 'EVS%' ORDER BY CreatedDate ASC

sfdf

SELECT Id, Name,CreatedDate FROM User WHERE IsActive = TRUE ORDER BY CreatedDate DESC

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Ride App</title>
  <link rel="stylesheet" href="styles.css">
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css">
</head>

<body>
  <div class="container">
    <header>
      <h1><i class="fas fa-taxi"></i> SOFI RIDE</h1>
    </header>
    <main>
      <form id="rideForm">
        <label for="pickup"><i class="fas fa-map-marker-alt"></i> Pickup Location:</label>
        <input type="text" id="pickup" name="pickup" required>
        <label for="dropoff"><i class="fas fa-map-pin"></i> Dropoff Location:</label>
        <input type="text" id="dropoff" name="dropoff" required>
        <button type="submit"><i class="fas fa-car"></i> Request Ride</button>
      </form>
      <div id="confirmation" class="hidden">
        <p><i class="fas fa-check-circle"></i> Your ride from <span id="pickupLocation"></span> to <span id="dropoffLocation"></span> has been requested!</p>
        <h2><i class="fas fa-car-side"></i> Available Rides:</h2>
        <ul id="ridesList"></ul>
      </div>
    </main>
    <footer>
      <p>&copy; 2024 Ride App</p>
    </footer>
  </div>
  <script src="scripts.js"></script>
</body>

</html>

function woodmart_child_enqueue_scripts()
{
	wp_enqueue_script(
		'child-scripts',
		get_stylesheet_directory_uri() . '/main.js',
		array('jquery'),
		null,
		true
	);
}
add_action('wp_enqueue_scripts', 'woodmart_child_enqueue_scripts');

var input = document.querySelectorAll('.wpens_email');
input.forEach(function (single) {
  single.setAttribute('placeholder', 'Email Address');
});

[wpens_easy_newsletter firstname="no" lastname="no" button_text="⟶"]

function hide_dashboard_widgets() {

echo '<style>#dashboard-widgets-wrap { display: none !important; }</style>';

}

add_action('admin_head', 'hide_dashboard_widgets');

//You can copy a JSON list of all the extensions and their URLs by going to chrome://extensions and entering this in your console
document.querySelector('extensions-manager').extensions_.map(({id, name, state, webStoreUrl}) => ({id, name, state, webStoreUrl}))

#include <bits/stdc++.h>
#define INF 10000000000
#define ll long long int
#define pb push_back
#define mp make_pair
#define FOR(i, n) for (long long int i = 0; i < n; i++)
#define FORR(i, a, b) for (int i = a; i < b; i++)
// think about a question calmly, don't get panic to solve A fast
// if after 10 mins you are unable to think anything see dashboard
using namespace std;

void djk_fun(vector<vector<vector<int>>> &adj, int src, vector<int> &dis)
{
    priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> pq;
    dis[src] = 0;
    pq.push({{0, src}});

    while (pq.size() > 0)
    {
        vector<int> vr = pq.top();
        pq.pop();

        int nod = vr[1];
        for (int i = 0; i < adj[nod].size(); i++)
        {
            int neg = adj[nod][i][0], wt = adj[nod][i][1];
            if (dis[nod] + wt < dis[neg])
            {
                dis[neg] = dis[nod] + wt;
                pq.push({dis[neg], neg});
            }
        }
    }
}

int short_path(vector<vector<vector<int>>> &adj, vector<vector<int>> &nh, int st, int en, int n)
{
    int m = nh.size(), ans = INT_MAX;
    // apply shortest path on src and dest
    vector<int> dis_src(n + 1, 1e9);
    vector<int> dis_dst(n + 1, 1e9);

    djk_fun(adj, st, dis_src);
    djk_fun(adj, en, dis_dst);

    for (int i = 0; i < m; i++)
    {
        int n1 = nh[i][0], n2 = nh[i][1], wt = nh[i][2];
        ans = min({ans, dis_src[n1] + wt + dis_dst[n2], dis_src[n2] + wt + dis_dst[n1]});
    }
    ans = min(ans, dis_src[en]);

    if(ans > 1e9)
    {
        return -1;
    }
    return ans;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    ll n, m, st, en;
    cin >> n >> m;

    vector<vector<vector<int>>> adj(n + 1, vector<vector<int>>());
    vector<vector<int>> nh;

    // construct graph using state highways
    for (int i = 0; i < m; i++)
    {
        int u, v, st, nt;
        cin >> u >> v >> st >> nt;

        nh.pb({u, v, nt});
        adj[u].pb({v, st});
        adj[v].pb({u, st});
    }
    cin >> st >> en;

    cout << short_path(adj, nh, st, en, n) << endl;
    return 0;
}

def find_type_of_research(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'eyebrow'}):
        return soup.find_all('lbj-title', attrs = {'variant':'eyebrow'})[0].text.strip()
    else:
        return np.nan

def find_title(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'heading-1'}):
        return soup.find_all('lbj-title', attrs = {'variant':'heading-1'})[0].text.strip()
    if soup.find_all('h1', attrs = {'class':'title heading-1'}):
        return soup.find_all('h1', attrs = {'class':'title heading-1'})[0].text.strip()
    return np.nan

def find_subtitle(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'subtitle'}):
        return soup.find_all('lbj-title', attrs = {'variant':'subtitle'})[0].text.strip()

def find_authors(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'paragraph'}):
        author_code = soup.find_all('lbj-title', attrs = {'variant':'paragraph'})[0]
        # find every lbj-link
        authors = author_code.find_all('lbj-link')
        authors = [author.text.strip() for author in authors]
        authors_str =  ', '.join(authors)
        return authors_str
    return np.nan

def find_date(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'date'}):
        date_code = soup.find_all('lbj-title', attrs = {'variant':'date'})[0]
        date = date_code.find_all('time')[0].text.strip()
        return date
    return np.nan

def find_report_link(soup):
    if soup.find_all('lbj-button'):
        return soup.find_all('lbj-button')[0].get('href')
    return np.nan

def find_tags(soup):
    if soup.find_all('lbj-link', attrs = {'variant':'tag'}):
        tags = soup.find_all('lbj-link', attrs = {'variant':'tag'})
        print(tags)

def find_data_json(soup):
    # get the javascript code
    script = soup.find_all('script', attrs = {'type':'text/javascript'})

    # found the json after dataLayer_tags
    pattern = 'dataLayer_tags = (.+);'
    for s in script:
        if re.search(pattern, str(s)):
            info_json = re.search(pattern, str(s)).group(1)
            # transform it into a dictionary
            info = eval(info_json)['urban_page']
            publish_date = info.get('publish_date')
            title = info.get('urban_title')
            research_area = info.get('research_area')
            authors = info.get('authors')
            publication_type = info.get('publication_type')
            eyebrow = info.get('eyebrow')
            tags = info.get('tags')
            
            return publish_date, title, research_area, authors, publication_type, eyebrow, tags, info_json
    return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan

df_links = pd.read_csv('urban_links.csv')
df_links_details = df_links.copy()

for i in range(len(df_links)):
    URL = "https://www.urban.org/" + df_links['link'][i]
    print(URL)
    r = requests.get(URL)
    soup = BeautifulSoup(r.content, 'html5lib')
    report_link = find_report_link(soup)
    publish_date, title, research_area, authors, publication_type, eyebrow, tags, info_json = find_data_json(soup)
    
    df_links_details.loc[i, 'eyebrow'] = eyebrow
    df_links_details.loc[i, 'title'] = title
    df_links_details.loc[i, 'authors'] = authors
    df_links_details.loc[i, 'date'] = publish_date
    df_links_details.loc[i, 'research_area'] = research_area
    df_links_details.loc[i, 'publication_type'] = publication_type
    df_links_details.loc[i, 'tags'] = tags
    df_links_details.loc[i, 'info_json'] = info_json
    df_links_details.loc[i, 'report_link'] = report_link
    
    print(publish_date, title, research_area, authors, publication_type, eyebrow, tags, report_link)
    
    if i % 200 == 0:
        df_links_details.to_csv('urban_links_details.csv', index = False)

df_links = []

PAGE_NUM = 281

for page in range(1, PAGE_NUM):
    URL = f"https://www.urban.org/research?page={page}"
    r = requests.get(URL) 
    soup = BeautifulSoup(r.content, 'html5lib')
    articles = soup.find_all('li', attrs = {'class':'mb-16 md:col-span-2 mb-8 sm:mb-0'})
    for article in articles:
        pattern = 'href="(.+?)"'
        if re.search(pattern, str(article)):
            df_links.append([page, re.search(pattern, str(article)).group(1)])
    print(f'Page {page} done')

df_links = pd.DataFrame(df_links, columns = ['page', 'link'])
df_links.to_csv('urban_links.csv', index = False)

<main>

  <span class="scroll">Scroll for more</span>

  <section class="shadow">

    <p data-attr="shadow">shadow</p>

  </section>

  <section class="break">

    <p data-attr="ak">bre</p>

  </section>

  <section class="slam">

    <p data-splitting>slam</p>

  </section>

  <section class="glitch">

    <p data-attr="glitch">glitch</p>

  </section>

</main>

from pydantic import BaseModel, Field
from uuid import UUID, uuid4

class item(BaseModel):
    name : str
    price : float
    item_id : UUID = Field(default_factory = uuid4)


items = []

for i in range(3):
    items.append(item(name = 'test', price = 20))


print(items)

Modified Script
python
Copy code
import os
import rasterio
import geopandas as gpd
from rasterio.mask import mask
import matplotlib.pyplot as plt

def convert_images_to_masks(input_image_dir, building_footprints_path, output_mask_dir):
    """
    Convert multiple satellite images to masks based on building footprints.
    """
    # Load the building footprints as a GeoDataFrame
    building_footprints = gpd.read_file(building_footprints_path)

    # Ensure both the raster and vector data are in the same CRS
    # Temporarily load the first image to get CRS
    first_image_path = os.path.join(input_image_dir, os.listdir(input_image_dir)[0])
    with rasterio.open(first_image_path) as src:
        satellite_meta = src.meta
    building_footprints = building_footprints.to_crs(crs=satellite_meta['crs'])

    # Iterate through each image in the input directory
    for file_name in os.listdir(input_image_dir):
        if file_name.endswith('.tif'):
            input_image_path = os.path.join(input_image_dir, file_name)
            output_mask_path = os.path.join(output_mask_dir, file_name.replace('.tif', '_mask.tif'))

            # Open the raster image
            with rasterio.open(input_image_path) as src:
                satellite_image = src.read()  # Read all bands
                satellite_meta = src.meta  # Metadata of the raster

            # Create a geometry mask from the building footprints
            geometries = building_footprints['geometry'].values

            # Clip the raster with the building footprints mask
            with rasterio.open(input_image_path) as src:
                out_image, out_transform = mask(src, geometries, crop=True)
                out_meta = src.meta.copy()
                out_meta.update({
                    "driver": "GTiff",
                    "height": out_image.shape[1],
                    "width": out_image.shape[2],
                    "transform": out_transform
                })

            # Save the clipped image
            with rasterio.open(output_mask_path, "w", **out_meta) as dest:
                dest.write(out_image)

            print(f"Processed and saved mask for {file_name}")

            # Display the result (optional)
            plt.figure(figsize=(10, 10))
            if out_image.shape[0] == 1:
                plt.imshow(out_image[0], cmap='gray')
            else:
                plt.imshow(out_image.transpose(1, 2, 0))
            plt.title(f'Clipped Satellite Image - {file_name}')
            plt.axis('off')  # Turn off axis labels
            plt.show()

# Example usage
input_directory = 'E:/isrooooooo/marchassam/satimgmarch/'  # Path to directory with TIFF images
building_footprints_path = 'C:/project isro/assambuildingfoot.shp'  # Path to building footprints
output_directory = 'E:/isrooooooo/marchassam/maskmarch/'  # Path to save masks

convert_images_to_masks(input_directory, building_footprints_path, output_directory)
Explanation
convert_images_to_masks Function:

Takes in the directory containing satellite images, the path to building footprints, and the output directory for masks.
Loads building footprints and ensures CRS alignment with the first image.
Processing Each Image:

Loops through all TIFF files in the input directory.
For each image, it applies the clipping process and saves the resulting mask.
Visualization:

Optionally displays the clipped image for each processed file.
File Handling:

Ensures each processed mask is saved with a unique name, corresponding to the original image file.
By following this script, you can efficiently process multiple satellite images and generate corresponding masks in one go. Adjust the directory paths and filenames as needed for your specific use case. If you encounter any issues or need further assistance, let me know!

#include<stdio.h>
void main()
{
    int a[5],i,j,n=5,temp;
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(i=0;i<n;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(a[j]>a[j+1])
            {
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    }
    for(i=0;i<n;i++)
    {
        printf("%d",a[i]);
    }
}

version: '3'
services:
  web:
    image: 'nginx:latest'
    ports:
      - '80:80'
  db:
    image: 'mysql:latest'
    environment:
      MYSQL_ROOT_PASSWORD: password

\xB0

bool isValidParenthesis (string expression) {
  stack<char> s;
  for (int i = 0; i < expression.length(); i++) {
    char ch = expression[i];
    // if opening bracket push it to stack
    // if closing bracket, pop from stack, check if the popped element is the                 matching opening bracket
    if (ch == '(' || ch =='{' || ch == '[') {
      s.push(ch);
    }
    else {
      // for closing bracket
      if (!s.empty()) {
        char top = s.top();
        if ((ch == ')' && top == '(') || (ch == '}' && top == '{') || (ch == ']' &&               top == '[')) {
          s.pop();
        }
      }
      else {
        return false;
      }
    }
  }
  if (s.empty()) {
    return true;
  }
  else {
    return false;
  }
}

// App.tsx
import React, { useState } from 'react';
import './App.css';

function App() {
  const [top, setTop] = useState(0);
  const [left, setLeft] = useState(0);
  const [backgroundColor, setBackgroundColor] = useState('#ffffff')

  const keyDownHandler = (e: React.KeyboardEvent<HTMLDivElement>) => {
    const key = e.code;

    if (key === 'ArrowUp') {
      setTop((top) => top - 10);
    }

    if (key === 'ArrowDown') {
      setTop((top) => top + 10);
    }

    if (key === 'ArrowLeft') {
      setLeft((left) => left - 10);
    }

    if (key === 'ArrowRight') {
      setLeft((left) => left + 10);
    }

    if (key === 'Space') {
      let color = Math.floor(Math.random() * 0xFFFFFF).toString(16);
      for(let count = color.length; count < 6; count++) {
        color = '0' + color;                     
      }
      setBackgroundColor('#' + color);
    }
  }

  return (
    <div
      className="container"
      tabIndex={0}
      onKeyDown={keyDownHandler}
    >
      <div
        className="box"
        style={{ 
          top: top,
          left: left,
          backgroundColor: backgroundColor,
        }}></div>
    </div>
  );
}

export default App;

node *findMid(node *head) {
  node *slow = head;
  node *fast = head->next;
  while (fast != NULL && fast->next != NULL) {
    slow = slow->next;
    fast = fast->next->next;
  }
  return slow;
}

node *merge(node *left, node *right) {
  if (left == NULL) {
    return right;
  }
  if (right == NULL) {
    return left;
  }
  node *ans = new node(-1);
  node *temp = ans;
  while (left != NULL && right != NULL) {
    if (left->data < right->data) {
      temp->next = left;
      temp = left;
      left = left->next;
    } else {
      temp->next = right;
      temp = right;
      right = right->next;
    }
  }
  while (left != NULL) {
    temp->next = left;
    temp = left;
    left = left->next;
  }
  while (right != NULL) {
    temp->next = right;
    temp = right;
    right = right->next;
  }
  ans = ans->next;
  return ans;
}

node *mergeSort(node *head) {
  // base case
  if (head == NULL || head->next == NULL) {
    return head;
  }
  // breaking the linked list into two halves
  node *mid = findMid(head);
  node *first = head;
  node *second = mid->next;
  mid->next = NULL;
  // recursive call
  first = mergeSort(first);
  second = mergeSort(second);
  // merging the two sorted halves
  node *result = merge(first, second);
  return result;
}

List<Account> accountList = [
    SELECT Id, Name, AccountNumber FROM Account WHERE Name LIKE 'Test Account - %' 
    LIMIT 10
];

Datetime startDttm = System.now();
Map<String, SObject> acctMapByNbr = 
    MapCreator.createMapByIndex( accountList, 'AccountNumber' );
system.debug( 'MapCreator -> ' + ( System.now().getTime() - startDttm.getTime() ) );

startDttm = System.now();
Map<String, SObject> acctMapByNbr2 = 
    new Map<String, SObject>();
for( Account anAccount : accountList ) {
	acctMapByNbr2.put( String.valueOf( anAccount.AccountNumber ), anAccount );
}
system.debug( 'standard map creation -> ' + ( System.now().getTime() - startDttm.getTime() ) );

using av_motion_api.Data;
using av_motion_api.Factory;
using av_motion_api.Models;
using av_motion_api.Interfaces;
using av_motion_api.Services;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.Extensions.Logging;
using System.Text;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.OpenApi.Models;

var builder = WebApplication.CreateBuilder(args);

// Configure the app environment
ConfigurationManager configuration = builder.Configuration;

builder.Configuration.SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json", optional: false);

builder.Host.ConfigureAppConfiguration((hostingContext, config) =>
{
    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
    config.AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json", optional: true);
});

// Configure logging
builder.Logging.ClearProviders();
builder.Logging.AddConsole();
builder.Logging.AddDebug();

// CORS
if (builder.Environment.IsDevelopment())
{
    builder.Services.AddCors(options =>
    {
        options.AddPolicy("AllowAll", policy =>
        {
            policy.AllowAnyOrigin()
                  .AllowAnyHeader()
                  .AllowAnyMethod();
        });
    });
}

// Add services to the container
builder.Services.AddControllers()
    .AddJsonOptions(options =>
    {
        options.JsonSerializerOptions.ReferenceHandler = System.Text.Json.Serialization.ReferenceHandler.Preserve;
    });

// SQL
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(configuration.GetConnectionString("DefaultConnection")));
builder.Services.AddScoped<IRepository, Repository>();

builder.Services.AddIdentity<User, Role>(options =>
                {
                    options.Password.RequireUppercase = false;
                    options.Password.RequireLowercase = false;
                    options.Password.RequireNonAlphanumeric = false;
                    options.Password.RequireDigit = true;
                    options.User.RequireUniqueEmail = true;
                })
                .AddRoles<Role>()
                .AddEntityFrameworkStores<AppDbContext>()
                .AddDefaultTokenProviders();

builder.Services.AddAuthentication(options =>
                {
                    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
                    options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
                })
                .AddCookie()
                .AddJwtBearer(options =>
                {
                    options.Events = new JwtBearerEvents
                    {
                        OnAuthenticationFailed = context =>
                        {
                            context.Response.Headers.Add("Authentication-Failed", context.Exception.Message);
                            return Task.CompletedTask;
                        },
                        OnTokenValidated = context =>
                        {
                            var logger = context.HttpContext.RequestServices.GetRequiredService<ILogger<StartupBase>>();
                            logger.LogInformation("Token validated for user: {0}", context.Principal.Identity.Name);
                            return Task.CompletedTask;
                        }
                    };
                    options.TokenValidationParameters = new TokenValidationParameters()
                    {
                        ValidateIssuer = true,
                        ValidateAudience = true,
                        ValidateLifetime = true,
                        ValidateIssuerSigningKey = true,
                        ValidIssuer = builder.Configuration["Tokens:Issuer"],
                        ValidAudience = builder.Configuration["Tokens:Audience"],
                        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Tokens:Key"]))
                    };
                });

// Configure FormOptions for file uploads
builder.Services.Configure<FormOptions>(o =>
{
    o.ValueLengthLimit = int.MaxValue;
    o.MultipartBodyLengthLimit = int.MaxValue;
    o.MemoryBufferThreshold = int.MaxValue;
});

builder.Services.AddScoped<IUserClaimsPrincipalFactory<User>, AppUserClaimsPrincipalFactory>();

builder.Services.Configure<DataProtectionTokenProviderOptions>(options => options.TokenLifespan = TimeSpan.FromHours(3));

// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
    // Add JWT Authentication to Swagger
    c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        Description = @"JWT Authorization header using the Bearer scheme. \r\n\r\n 
          Enter 'Bearer' [space] and then your token in the text input below.
          \r\n\r\nExample: 'Bearer 12345abcdef'",
        Name = "Authorization",
        In = ParameterLocation.Header,
        Type = SecuritySchemeType.ApiKey,
        Scheme = "Bearer"
    });

    c.AddSecurityRequirement(new OpenApiSecurityRequirement()
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference
                {
                    Type = ReferenceType.SecurityScheme,
                    Id = "Bearer"
                },
                Scheme = "oauth2",
                Name = "Bearer",
                In = ParameterLocation.Header,
            },
            new List<string>()
        }
    });
});

var app = builder.Build();

// Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

// Use CORS
app.UseCors("AllowAll");

app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();

app.Use(async (context, next) =>
{
    var logger = app.Services.GetRequiredService<ILogger<Program>>();
    logger.LogInformation("Handling request: " + context.Request.Path);
    await next.Invoke();
    logger.LogInformation("Finished handling request.");
});

app.Run();

//Method before error
loadRewardTypes(): void {
    this.rewardTypeService.getAllRewardTypes().subscribe((rewardTypes: RewardTypeViewModel[]) => {
      this.rewardTypes = rewardTypes;
      this.filteredRewardTypes = rewardTypes;
    });
  }
  
//Method after error
loadRewardTypes(): void {
    this.rewardTypeService.getAllRewardTypes().subscribe({
      next: (rewardTypes: RewardTypeViewModel[]) => {
        console.log('API Response:', rewardTypes); // Check if the data is an array
        this.rewardTypes = Array.isArray(rewardTypes) ? rewardTypes : [];
        this.filteredRewardTypes = this.rewardTypes;
        console.log('Assigned rewardTypes:', this.rewardTypes); // Confirm assignment
      },
      error: (error) => {
        console.error('Error loading reward types:', error);
      }
    });
  }

App\Models\Category {#310 ▼ // resources\views/courses/show.blade.php
  #connection: null
  #table: null
  #primaryKey: "id"
  #keyType: "int"
  +incrementing: true
  #with: []
  #withCount: []
  +preventsLazyLoading: false
  #perPage: 15
  +exists: false
  +wasRecentlyCreated: false
  #escapeWhenCastingToString: false
  #attributes: []
  #original: []
  #changes: []
  #casts: []
  #classCastCache: []
  #attributeCastCache: []
  #dateFormat: null
  #appends: []
  #dispatchesEvents: []
  #observables: []
  #relations: []
  #touches: []
  +timestamps: true
  +usesUniqueIds: false
  #hidden: []
  #visible: []
  #fillable: array:2 [▶]
  #guarded: array:1 [▶]
}

onSubmit() {
    if (this.profileForm.valid) {
      const userId = JSON.parse(localStorage.getItem('User')!).userId;
      this.userService.updateUser(userId, this.profileForm.value).subscribe({
        next: (result) => {
          console.log('User to be updated:', result);
          this.router.navigateByUrl(`/ProfilePage/${userId}`);
          alert('Successfully updated profile');
        },
        error: () => {
          console.error('Error updating user profile:');
          alert('Error updating profile');
        }
      });
    }
  }

onPhotoChange(event: Event): void {
    if (!this.isEditMode) return;

    const input = event.target as HTMLInputElement;
    if (input.files && input.files[0]) {
      const reader = new FileReader();
      reader.onload = (e: any) => {
        this.userProfileImage = e.target.result; // Update the image source
        this.profileForm.patchValue({ photo: e.target.result }); // Update the form control
      };
      reader.readAsDataURL(input.files[0]);
    }
  }

<link href="splendor.css" rel="stylesheet">

<script type="application/ld+json">
{
  "@context": "https://schema.org/", 
  "@type": "Product", 
  "name": "Terminus Developers",
  "image": "https://terminus-developers.com/wp-content/themes/terminus/assets/images/projects/_MG_4516.webp",
  "description": "Terminus Developers: Offering Premium Building Construction, Real Estate Services, and a Range of Flats, Plots, and Apartments in TSPA Junction, Kokapet, Kollur, Hyderabad.",
  "brand": {
    "@type": "Brand",
    "name": "Terminus"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "bestRating": "5",
    "worstRating": "1",
    "ratingCount": "836"
  }
}
</script>