ToCode

$ git init .
$ echo hello > file1.txt
$ git add .
$ git commit -m 'initial commit'

$ git mv file1.txt file2.txt
$ git status

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        renamed:    file1.txt -> file2.txt
        
$ git commit -m 'rename'

$ git log -p --oneline

25ccbd7 (HEAD -> main) rename
diff --git a/file1.txt b/file2.txt
similarity index 100%
rename from file1.txt
rename to file2.txt
0e6c0e3 initial commit
diff --git a/file1.txt b/file1.txt
new file mode 100644
index 0000000..ce01362
--- /dev/null
+++ b/file1.txt
@@ -0,0 +1 @@
+hello

$ git log -p --oneline --no-renames
25ccbd7 (HEAD -> main) rename
diff --git a/file1.txt b/file1.txt

deleted file mode 100644
index ce01362..0000000
--- a/file1.txt
+++ /dev/null
@@ -1 +0,0 @@
-hello
diff --git a/file2.txt b/file2.txt

new file mode 100644
index 0000000..ce01362
--- /dev/null
+++ b/file2.txt
@@ -0,0 +1 @@
+hello
0e6c0e3 initial commit
diff --git a/file1.txt b/file1.txt

new file mode 100644
index 0000000..ce01362
--- /dev/null
+++ b/file1.txt
@@ -0,0 +1 @@
+hello

$ git diff --name-status HEAD~
R100    file1.txt       file2.txt

$ git diff --name-status --no-renames HEAD~
D       file1.txt
A       file2.txt

$ pip install -r requirements.txt

$ python main.py

$ cd frontend
$ yarn dev

@sio.on('message')
async def print_message(sid, message):
    print("Socket ID: " , sid)
    print(message)
    await sio.emit('message', message, broadcast=True);

from aiohttp import web
import socketio

static_files = {
    '/static': './frontend/dist',
}


sio = socketio.AsyncServer(cors_allowed_origins='*', aync_mode='aiohttp')
app = web.Application()
app.add_routes([web.static('/static', './public')])

sio.attach(app)

@sio.on('message')
async def print_message(sid, message):
    print("Socket ID: " , sid)
    print(message)
    await sio.emit('message', message, broadcast=True);

if __name__ == '__main__':
    web.run_app(app)

import React from 'react'
import ReactDOM from 'react-dom'
import './index.css'
import App from './App'

import { IoProvider } from 'socket.io-react-hook';

ReactDOM.render(
  <React.StrictMode>
    <IoProvider>
      <App />
    </IoProvider>
  </React.StrictMode>,
  document.getElementById('root')
)

import './App.css'
import { useState, useEffect } from 'react';
import { useSocket, useSocketEvent } from 'socket.io-react-hook';

function App() {
  const [text, setText] = useState('');
  const { socket, error } = useSocket('http://localhost:8080');  
  const { lastMessage } = useSocketEvent(socket, 'message');

  useEffect(function() {
    if (lastMessage && lastMessage !== text) {
      setText(lastMessage);
    }
  }, [lastMessage]);

  if (error) {
    return <p>{String(error)}</p>
  }

  function handleChange(e) {
    setText(e.target.value);
    socket.emit('message', e.target.value);
  }

  return (
    <div>
      <input type="text" value={text} onChange={handleChange} />
      <p>Last message = {lastMessage}</p>
    </div>
  );
}

export default App

function showLink(props) {
  return (
    `<a
      ${props.href ? `href="${props.href}"` : ''}
      ${props.title ? `title="${props.title}"` : ''}
      >${props.text ? props.text : ''}
    </a>`
  );
}

function showLinkBetter(props) {
  const { href, title } = attrs(props);
  const { text } = values(props);

  return (
    `<a ${href} ${title}>${text}</a>`
  );
}

function returnTextProxy(props, withPrefix) {
  return new Proxy(props, {
    get: function(target, prop, _receiver) {
      if (target[prop]) {
        return withPrefix ? `${prop}="${target[prop]}"` : target[prop];
      } else {
        return "";
      }
    }
  });
}

function attrs(props) {
  return returnTextProxy(props, true);
}

function values(props) {
  return returnTextProxy(props, false);
}

const countries = Object.keys(db);
const selectedCountry = ref("");
const cities = computed(() => db[selectedCountry.value] || []);
const selectedCity = ref("");

watchEffect(() => {
  if (!cities.value.includes(selectedCity.value)) {
    selectedCity.value = '';
  }
});

</script>

<template>
<div>
  <select v-model="selectedCountry">
    <option value="" disabled="true">Please select a country</option>
    <option v-for="country in countries" :value="country">{{country}}</option>
  </select>

  <p>Selected country = {{selectedCountry}}</p>
  <pre>Cities = {{cities}}</pre>

  <select v-model="selectedCity">
    <option value="" disabled="true">Please select city</option>
    <option v-for="city in cities" :value="city">{{city}}</option>
  </select>
  <p>You selected country = {{selectedCountry}} and city = {{selectedCity}}</p>
</div>
</template>

<style scoped>
</style>

import React from 'react';

function Yo() {
  React.useEffect(function() {
    alert('bye bye');
  }, []);

  return <p>Yo</p>;
}

export default function App() {
  function handleClick() {
  }

  return (
    <div className="App">
      <Yo />
      <button onClick={handleClick} >Say bye bye</button>
    </div>
  );
}

|> filter$((k, v) -> v > 1)

1 1 1 1 1 
2 2 2 2 
3 3 3 
4 4 
5

rows = 5
x = 0
# reverse for loop from 5 to 0
for i in range(rows, 0, -1):
    x += 1
    for j in range(1, i + 1):
        print(x, end=' ')
    print('\r')

def triangle(size)= (
    range(size, 0, -1)
    |> map$(i -> [i, size-i + 1])
    |> map$(x -> f"{x[1]} " * x[0])
    |> '\n'.join)


print(triangle(5))

$ pip install coconut

text = 'My Name is Jessa'

yM emaN si asseJ

def reverse_words(Sentence):
    words = Sentence.split(" ")
    new_word_list = [word[::-1] for word in words]
    res_str = " ".join(new_word_list)
    return res_str

# Given String
str1 = "My Name is Jessa"
print(reverse_words(str1))

def reverse_words(sentence) = (
    sentence
       |> .split(" ")
       |> map$(n -> n[::-1])
       |> list
       |> ' '.join)

reverse_words("My Name is Jessa") |> print

with open('sample.txt', 'r') as file:
    data = file.read().replace('\n', ' ')
    print(data)

with open("sample.txt") as file:
    (file.read()
    |> .replace("\n", " ")
    |> print)

ascii_dict = {'A': 65, 'B': 66, 'C': 67, 'D': 68}

{65: 'A', 66: 'B', 67: 'C', 68: 'D'}

ascii_dict = {'A': 65, 'B': 66, 'C': 67, 'D': 68}
# Reverse mapping
new_dict = {value: key for key, value in ascii_dict.items()}
print(new_dict)

({'A': 65, 'B': 66, 'C': 67, 'D': 68}
    |> fmap$((k, v) -> [v, k])
    |> print)

sample_list = [10, 20, 60, 30, 20, 40, 30, 60, 70, 80]

import collections

sample_list = [10, 20, 60, 30, 20, 40, 30, 60, 70, 80]

duplicates = []
for item, count in collections.Counter(sample_list).items():
    if count > 1:
        duplicates.append(item)
print(duplicates)

import collections
sample_list = [10, 20, 60, 30, 20, 40, 30, 60, 70, 80]

(sample_list
    |> collections.Counter
    |> .items()
    |> filter$(x -> x[1] > 1)
    |> map$(x -> x[0])
    |> list
    |> print)