Tuesday, March 5, 2024

Informații E-Factura

Ministerul Finanțelor a decis ca amenzile pentru netransmiterea facturilor în sistemul naţional RO e-Factura să înceapă de la 1 iunie. Agenții economici care nu țin cont de termenul-limită de 5 zile lucrătoare pentru transmiterea facturilor în sistemul naţional privind factura electronică RO e-Factura, vor fi sancționați de la 1 iunie 2024. Nerespectarea termenului limită pentru transmiterea facturilor în sistemul național privind factura electronică RO e-Factura constituie contravenție și se sancționează cu amendă de la 5.000 lei la 10.000 lei, pentru persoanele juridice încadrate în categoria contribuabililor mari, definiți potrivit legii, cu amendă de la 2.500 lei la 5.000 lei, pentru persoanele juridice încadrate în categoria contribuabililor mijlocii, definiți potrivit legii, și cu amendă de la 1.000 lei la 2.500 lei, pentru celelalte persoane juridice, precum și pentru persoanele fizice. Totodată, netransmiterea de către emitent a facturii în sistemul național privind factura electronică RO e-Factura, precum și primirea și înregistrarea de către destinatari - persoane impozabile stabilite în România conform art. 266 alin. (2) din Codul fiscal, a unei facturi emise de operatori economici stabiliți în România, în relația B2B, fără a fi respectate prevederile art. 10, alin. (1) din OUG nr. 120/2021, constituie contravenție și se sancționează cu o amendă egală cu 15% din valoarea totală a facturii.

Citește mai mult la: https://www.digi24.ro/digieconomic/financiar/e-factura-de-la-1-iunie-2024-incep-amenzile-19733

Informaţiile publicate pe site-ul Digi Economic pot fi preluate, în conformitate cu legislația aplicabilă, doar în limita a 120 de caractere.

Guvernul a aprobat, în ședința de azi, 21 iunie, la propunerea Ministerului Finanțelor, o serie de acte normative, prin care s-au reglementat mai multe lucruri, printre care și aplicarea obligatorie a e-Factura în vânzările firmelor către clienți finali. e-Factura a devenit obligatorie de la 1 ianuarie 2024 doar în relațiile comerciale dintre firme. De la 1 ianuarie 2025 se extinde la toate vânzările/cumpărările.

De la 1 ianuarie 2025, facturarea electronică pentru relația între companii și consumatorii finali (B2C) este obligatorie
Tot astăzi, s-a aprobat actul normativ prin care se extinde utilizarea sistemului de facturare electronică și pentru tranzacțiile între afaceri și consumatorii finali (B2C), în mod opțional în perioada 1 iulie 2024 – 31 decembrie 2024 și obligatoriu începând cu 1 ianuarie 2025. În consecință, toate persoanele impozabile care emit facturi către consumatori vor trebui să le raporteze în sistemul RO e-Factura.e-Factura a fost introdusă în 2022 pentru tranzacțiile business to government (B2G), adică pe contractele dintre stat și firme. Ea a devenit obligatorier în relațiile comerciale dintre firme (B2B) la 1 ianuarie 2024, și de la 1 iulie devine singura formă de factură legală în B2G din România, cu excepția tranzacțiilor externe, inclusiv cu UE. 

Acum. e-Factura este extinsă, de la 1 ianuarie 2025, și la clienții finali, prin OUG dată azi.

Aflați, mai departe, ce schimbări au avut azi loc la șredința de guvern, din  punct de vedere fiscal. Redăm comunicatul Ministerului de Finanțe.

1. Modul de implementare a decontului precompletat RO e-TVA și modul de guvernanță raportat la atribuțiile autorităților implicate în gestionarea acestuia.
2. Extinderea utilizării sistemului de facturare electronică și pentru tranzacțiile între afaceri și consumatorii finali (B2C), în mod opțional în perioada 1 iulie 2024 – 31 decembrie 2024 și obligatoriu începând cu 1 ianuarie 2025.
3. Prelungire până la data de 30 septembrie 2024 a perioadei de aplicare a HG nr.1326/2023 privind stabilirea tarifelor de primă maxime de asigurare.

„Este o zi importantă pentru digitalizarea sistemului fiscal și pentru lupta noastră cu evaziunea fiscală, odată cu introducerea normelor pentru e-TVA și extinderea ariei de acoperire a e-Factura. Decontul precompletat va conține date și informații privind operațiunile economice declarate de către persoanele impozabile și transmise în sistemele informatice ale ANAF. Vorbim despre un instrument digital integrator al datelor și informațiilor conținute în aceste sisteme informatice care să contribuie la prevenirea completării eronate a decontului de TVA. Adoptarea unui astfel instrument a rezultat și din dialogul constant pe care l-am cu mediul de afaceri, care a solicitat explicitarea modului în care administrația fiscală utilizează datele aflate la dispoziție. Cât despre introducerea obligativității e-Factura în regim B2C, ne va ajuta tot în această privință, pentru a avea o imagine cât mai exactă în decontul precompletat RO e-TVA”, a explicat ministrul Marcel Boloș.

1. Sistemul RO e-TVA se implementează cu data de 1 august 2024 pentru operațiunile efectuate începând cu data de 1 iulie 2024 de persoanele impozabile înregistrate în scopuri de TVA și se transmite, pentru fiecare perioadă fiscală de raportare, prin intermediul SPV, până la data de 20 inclusiv a fiecărei luni următoare încheierii perioadei fiscale.

Implementarea decontului precompletat și a modalității de valorificare a datelor și informațiilor din Sistemul informatic național RO e-TVA vizează:

  • reducerea decalajului fiscal în domeniul TVA rezultat din estimările macroeconomice realizate la nivel național și implicit asigurarea încadrării în țintele asumate de România prin jaloanele Planului Național de Redresare și Reziliență;
  • creșterea gradului de conformare voluntară care să conducă la asigurarea încasării sumelor din TVA la bugetul de stat general consolidat;
  • reducerea impactului evaziunii fiscale rezultate din activitățile economice ilicite desfășurate de contribuabili, respectiv din modul de evidențiere și înregistrare a operațiunilor impozabile specifice TVA-ului;
  • consolidarea capacității instituționale a Agenției Naționale de Administrare Fiscală de colectare a impozitelor și taxelor prin implementarea unor proiecte de digitalizare.

Decontul precompletat RO e-TVA conține date și informații privind operațiunile economice declarate de către persoanele impozabile și transmise în sistemele informatice ale Ministerului Finanțelor și Agenției Naționale de Administrare Fiscală (RO e-Factura, RO e-Sigiliu, RO e-Transport, RO e-SAF-T, RO e-Case de marcat electronice, sistemul informatic integrat vamal).

După primirea decontului precompletat RO e-TVA, persoanele impozabile înregistrate în scopuri de TVA vor verifica datele și informațiile precompletate în concordanță cu operațiunile impozabile realizate și starea de fapt fiscală. Indiferent de primirea decontului precompletat RO e-TVA, persoana impozabilă are obligația de a transmite decontul de taxă pe valoarea adăugată până la termenul prevăzut de lege.

În situația în care după depunerea decontului de taxă pe valoarea adăugată sunt diferențe semnificative între valorile precompletate prin intermediul decontului precompletat RO e-TVA și valorile completate de către contribuabili, ANAF notifică persoana impozabilă prin SPV.

Sunt considerate diferențe semnificative valorile care depășesc pragul de semnificație ce îndeplinește condițiile cumulative de minim 20% în cotă procentuală și o valoare absolută de minim 1.000 lei, rezultate din compararea valorilor înscrise în rândurile din decontul de taxă pe valoarea adăugată depus de persoana impozabilă, cu cele corespunzătoare rândurilor din decontul precompletat RO e-TVA.

După identificarea diferențelor semnificative, se va transmite formularul electronic de notificare „Diferențe operațiuni impozabile RO e-TVA” în Spațiul privat virtual, iar contribuabilul are obligația transmiterii formularului electronic denumit "Notă justificativă privind diferențe RO e-TVA prin mijloacele electronice, ca rezultat al verificărilor realizate asupra diferențelor comunicate".

Suplimentar, prin același act normativ se reglementează faptul că nefurnizarea sau furnizarea parțială a informațiilor solicitate prin Nota justificativă privind diferențe RO e-TVA reprezintă indicator de risc fiscal privind nivelul de declarare al taxei pe valoare adăugată. În funcție de nivelul riscului fiscal al persoanei impozabile, stabilit pe baza analizei de risc, aceasta poate face obiectul inspecției fiscale sau controlului antifraudă.

Decontul precompletat RO e-TVA nu constituie titlu de creanță în sensul Legii nr.207/2015 privind Codul de procedură fiscală, cu modificările și completările ulterioare și nu generează obligații fiscale în sarcina persoanelor impozabile înregistrate în scopuri de TVA.

Ministerul Finanțelor a decis ca amenzile pentru netransmiterea facturilor în sistemul naţional RO e-Factura să înceapă de la 1 iunie. 

Agenții economici care nu țin cont de termenul-limită de 5 zile lucrătoare pentru transmiterea facturilor în sistemul naţional privind factura electronică RO e-Factura, vor fi sancționați de la 1 iunie 2024.

Nerespectarea termenului limită pentru transmiterea facturilor în sistemul național privind factura electronică RO e-Factura constituie contravenție și se sancționează cu amendă de la 5.000 lei la 10.000 lei, pentru persoanele juridice încadrate în categoria contribuabililor mari, definiți potrivit legii, cu amendă de la 2.500 lei la 5.000 lei, pentru persoanele juridice încadrate în categoria contribuabililor mijlocii, definiți potrivit legii, și cu amendă de la 1.000 lei la 2.500 lei, pentru celelalte persoane juridice, precum și pentru persoanele fizice.

Totodată, netransmiterea de către emitent a facturii în sistemul național privind factura electronică RO e-Factura, precum și primirea și înregistrarea de către destinatari - persoane impozabile stabilite în România conform art. 266 alin. (2) din Codul fiscal, a unei facturi emise de operatori economici stabiliți în România, în relația B2B, fără a fi respectate prevederile art. 10, alin. (1) din OUG nr. 120/2021, constituie contravenție și se sancționează cu o amendă egală cu 15% din valoarea totală a facturii.

În situaţia în care sistemul naţional privind factura electronică RO e-Factura nu este funcțional timp de minimum 24 de ore, obligația de transmitere a facturii se suspendă până la repunerea în funcţiune a sistemului. 

Pe perioada în care sistemul naţional privind factura electronică RO e-Factura nu este funcțional, emitentul facturii aplică în mod corespunzător prevederile art. 319 din Legea nr. 227/2015, cu modificările şi completările ulterioare, cu condiția transmiterii ulterioare, în
sistemul național privind factura electronică RO e-Factura, a facturilor electronice emise. 

Perioadele de nefuncţionare a sistemul naţional privind factura electronică RO e-Factura vor fi publicate pe paginile de internet ale Agenţiei Naţionale de Administrare Fiscală şi Ministerului Finanţelor.

Mai multe detalii aflați din Ghidul e-Factura întocmit și actualizate de Ministerul Finanțelor.

De la 1 iulie e-Factura rămâne singura factură B2B

Până la 30 iunie 2024, operatorii economici - persoane impozabile stabilite în România, indiferent dacă sunt sau nu înregistrate în scopuri
de TVA au obligația să raporteze în sistemul național privind factura electronică RO e-Factura toate facturile emise în relația B2B și în relația cu instituțiile publice.

De la 1 iulie vor fi eliminate toate tipurile de facturi inter-firme și va rămâne exclusiv e-Factura.

Ministerul Finanţelor anunţă lansarea versiunii simplificate a aplicaţiei e-Factura. Ministrul de resort, Marcel Boloş, spune că aceasta este în primul rând utilă celor aproximativ 670.000 contribuabili mici care au nevoie de un format gratuit şi uşor de folosit.

”În continuarea eforturilor de digitalizare şi simplificare a procedurilor fiscale, Ministerul Finanţelor anunţă lansarea versiunii simplificate a aplicaţiei e-Factura”, anunţă ministerul, potrivit News.ro

Versiunea îmbunătăţită vine cu o interfaţă intuitivă şi funcţionalităţi mai uşor de utilizat, astfel încât fiecare utilizator să poată emite facturi în conformitate cu cerinţele fiscale într-un mod rapid şi eficient.

„Aşa cum am mai spus, fiecare îmbunătăţire adoptată a ţinut cont de nevoile semnalate de contribuabili. Am tot avut întâlniri cu reprezentaţii mediului de afaceri şi una dintre solicitările lor a fost aceasta. Versiunea simplificată a aplicaţiei e-Factura vine cu o serie de avantaje şi funcţionalităţi care vor face gestionarea facturilor mai uşoară şi mai accesibilă pentru toţi utilizatorii. Ne-am gândit în primul rând la cei aproximativ 670.000 contribuabili mici care trebuie să utilizeze sistemul şi au nevoie de o aplicaţie gratuită, intuitivă şi uşor de folosit. De asemenea, aplicaţia extinsă este acum disponibilă şi în limba engleză, urmând ca în perioada următoare să fie tradusă şi cea simplificată”, a explicat ministrul Marcel Boloş.

Aplicaţia web de completare a facturii într-un format simplificat răspunde solicitărilor venite din partea micorintreprinderilor, ce nu utilizează în mod curent elemente operaţionale complexe.

A fost redesenată pentru a include automat ghidaje (i.e. codul tipului facturii este prestabilit la 380, codul monedei este exclusiv RON) şi bife pentru a afişa elementele de identificare obligatorii în funcţie de categoria de plătitor de TVA.

Au fost restrânse nomenclatoarele de TVA la cele utilizate frecvent pentru tranzacţii domestice şi incluse procentele de taxă sub format selectabil.

De asemenea, o nouă facilitate importantă adăugată sistemului este aplicaţia extinsă în limba engleză pentru contribuabilii nerezidenţi înregistraţi în scopuri de TVA ce au obligaţia de raportare a facturilor emise pentru livrări/prestări pe teritoriul României.

În situaţia în care sistemul naţional privind factura electronică RO e-Factura nu este funcţional timp de minimum 24 de ore, obligaţia de transmitere prevăzută la art.10 alin.(1) din Ordonanţa de urgenţă a Guvernului nr.120/2021 se suspendă până la repunerea în funcţiune a sistemului.

Termenul-limită pentru transmiterea facturilor emise, pentru livrările de bunuri şi prestările de servicii care au locul livrării sau prestării în România, în sistemul naţional privind factura electronică RO e-Factura este de 5 zile lucrătoare (n.r. de la 1 iulie sunt 5 zile calendaristice) de la data emiterii facturii, dar nu mai târziu de 5 zile lucrătoare de la data-limită prevăzută pentru emiterea facturii la art.319 alin.(16) din Codul fiscal.

În perioada 1 ianuarie - 31 martie 2024, nerespectarea termenului limită pentru transmiterea facturilor în sistemul naţional privind factura electronică RO e-Factura nu se sancţionează.

e-Factura va fi mai ușor de folosit, spune ANAF, care face o aplicație care se adresează afacerilor mici, cu puține facturi pe lună. Aplicația poate fi accesată de marți dimineață, 5 martie 2024.

„Cuprinde doar elementele informaționale de bază, face în mod automat și selecția tipului de factură. Pentru că se agresează atât categoriei, cât și celor neplătitori de TVA. Se aplică o bifă, practic este intuitiv aici, nu mai este lăsat la libera alegere”.

Aplicația simplificată e-Factura a fost creată pentru cele peste 400.000 de afaceri mici, care emit puține facturi pe lună și nu au nevoie de informații suplimentare, cum ar fi referințe de lot sau de comandă pentru produse. Doar elementele obligatorii. Astfel că nu va fi nevoie de un soft diferit de facturare, iar procesul va dura foarte puțin, spun reprezentanții ANAF.

Aplicația va fi disponibilă pe site-ul Ministerul de Finanțe și va avea un buton separat, dar rămâne și aplicația obișnuită e-Factura.

„Numărul lor este destul de consistent, mai ales al celor care încă nu înțeleg că trebuie să utilizeze e-Factura și din calculele noastre undeva între 150.000 și 200.000. Aceștia sunt primii care vor primit aceste note de conformare. În caz contrar, riscă amenzi”. Până pe 31 martie, cei care nu transmit facturi în noul sistem nu vor fi sancționați. Ministerul analizează acum posibilitatea ca acest termen de grație să se amâne până pe 1 iulie, însă nu a fost luată o decizie până acum.

-----

De la 1 ianuarie 2024 în relaţia business-to-business (B2B), până în prezent, aproximativ 40 milioane de facturi au fost înregistrate cu succes în sistemul e-Factura, în valoare totală de 397 miliarde de lei.

Un aspect important pe care l-au semnalat contribuabilii a fost imposibilitatea accesării sistemului în situaţiile în care au loc lucrări de mentenanţă la nivelul Spaţiului Privat Virtual (SPV). În acest sens, utilizarea e-Factura se poate face acum direct de pe site-ul ANAF. Trebuie însă ca utilizatorul să aibă cont în SPV, unde s-a înregistrat în baza certificatului digital.

Potrivit comunicatului de pe site-ul ministerului, în situaţia în care sistemul naţional privind factura electronică RO e-Factura nu este funcțional timp de minimum 24 de ore, obligația de transmitere prevăzută la art.10 alin.(1) din Ordonanţa de urgenţă a Guvernului nr.120/2021 se suspendă până la repunerea în funcţiune a sistemului.

Termenul-limită pentru transmiterea facturilor emise, pentru livrările de bunuri și prestările de servicii care au locul livrării sau prestării în România, în sistemul național privind factura electronică RO e-Factura este de 5 zile lucrătoare (n.r. de la 1 iulie sunt 5 zile calendaristice) de la data emiterii facturii, dar nu mai târziu de 5 zile lucrătoare de la data-limită prevăzută pentru emiterea facturii la art.319 alin.(16) din Codul fiscal.

În perioada 1 ianuarie - 31 martie 2024, nerespectarea termenului limită pentru transmiterea facturilor în sistemul național privind factura electronică RO e-Factura nu se sancționează.

-----

Ultima noutate în ce privește e-Factura este că în sfârșit se poate face automat conversia din XML în PDF, printr-o simplă apăsare de buton. Ministrul a insistat mult pentru asta. Până acum conversia se făcea manual, iar Finanțele au raportat și un milion de facturi pe zi. Sursele noastre din Ministerul Finanțelor spun că îmbunătățirile pentru această schimbare majoră de sistem de raportare a facturilor, care a luat pe toată lumea prin surprindere, se realizează constant.

Trecerea la sistemul unic de raportare a facturilor în mediu electronic la ANAF a întâmpinat o serie de probleme în aplicare, de la 1 ianuarie, când e-Factura a devenit obligatorie în relațiile comerciale dintre firme.

E-Factura se aplică încă din 2022 pe relația firme - guvern. Dacă firmele mari sau cele care au business cu statul erau obișnuite cu birocrația și au găsit soluții să folosească sistemul așa cum a fost făcut inițial, trecerea la acest sistem pentru toate firmele a arătat slăbiciuni ale acestuia.

A fost introdusă autofacturarea. Apoi, conform unui comunicat transmis de Ministerul Finanțelor, începând cu 16 ianuarie 2024, sistemul e-Factura nu va mai permite introducerea facturilor duplicat. Această măsură vine să crească acuratețea și integritatea datelor înregistrate în sistem.
După încărcarea facturii fără Spațiul Privat Virtual, s-a mai introdus filtrarea pe categorii. Furnizorii de servicii de contabilitate au cerut să poată filtra facturile în baza anumitor criterii specifice. Această facilitate a fost introdusă printr-o modificare la apelul de listă facturi disponibile de la serviciile web apelabile automat prin API.

În final, a fost introdusă conversia automată din XML în PDF. 

e-Factura

a devenit obligatorie de la 1 ianuarie 2024. Nedepunerea ei în sistemul ANAF nu produce încă efecte, dar ar putea fi sancționată cu amendă, de la 1 aprilie.  De la 1 iulie, toate facturile dintre firme se vor transmite explusiv prin acest sistem. În jur de 120.000 de firme au depus până acum e-Factura, dintr-un total de aproximativ 700.000.
 
20.03.2024 - Până în 31 mai, ca urmare a faptului că încă sunt 74.000 de plătitori de TVA care nu folosesc e-Factura. Vor primi notificări. Cu data de 1 iulie amenda este de 15% din valoarea facturii, a spus Marcel Boloș, ministrul Finanțelor. Perioada în care nu sunt aplicate sancțiuni pentru nerespectarea obligației de a transmite facturile emise și în sistemul e-Factură  va fi extinsă până la 31 mai, a spus ministrul Finanțelor, Marcel Boloș pentru profit.ro.Marcel Boloș, ministrul Finanțelor, lua deja în calcul o potențială amânare a termenului de la care încep să fie aplicate sancțiuni pentru neraportarea și în sistemul eFactura a facturilor emise, în termenul de 5 zile stabilit.

Ministerul Finanțelor analiza situația e-Factura și lua în calcul o potențială amânare a termenului de la care încep să fie aplicate sancțiuni pentru neraportarea și în sistemul eFactura a facturilor emise. Până acum, sancțiunile erau suspendate până la 1 aprilie.

În sistemul e-Factura sunt raportate în prezent aproximativ o treime din numărul total de facturi la care estimează autoritățile că trebuie să se ajungă, dacă raportează toți cei care au obligația.

Până în 31 mai, ca urmare a faptului că încă sunt 74.000 de plătitori de TVA care nu folosesc e-Factura. Vor primi notificări. Cu data de 1 iulie amenda este de 15% din valoarea facturii, a spus Marcel Boloș, ministrul Finanțelor. Perioada în care nu sunt aplicate sancțiuni pentru nerespectarea obligației de a transmite facturile emise și în sistemul e-Factură va fi extinsă până la 31 mai, a spus ministrul Finanțelor, Marcel Boloș pentru profit.ro. Marcel Boloș, ministrul Finanțelor, lua deja în calcul o potențială amânare a termenului de la care încep să fie aplicate sancțiuni pentru neraportarea și în sistemul eFactură a facturilor emise, în termenul de 5 zile stabilit. Ministerul Finanțelor analizea situația e-Factura și lua în calcul o potențială amânare a termenului de la care încep să fie aplicate sancțiuni pentru neraportarea și în sistemul eFactură a facturilor emise. Până acum, sancțiunile erau suspendate până la 1 aprilie. În sistemul e-Factura sunt raportate în prezent aproximativ o treime din numărul total de facturi la care estimează autoritățile că trebuie să se ajungă, dacă raportează toți cei care au obligația.

Citește mai mult la: https://www.digi24.ro/digieconomic/financiar/decizie-bolos-nu-se-mai-dau-amenzi-pentru-e-factura-de-la-1-aprilie-13691

Informaţiile publicate pe site-ul Digi Economic pot fi preluate, în conformitate cu legislația aplicabilă, doar în limita a 120 de caractere.

-----

 

Tuesday, November 14, 2023

Server Send Events Stream SSE + Javascript

from quart import abort, make_response, request, Quart

app = Quart(__name__)
@app.get("/sse")
async def sse():
    if "text/event-stream" not in request.accept_mimetypes:
        abort(400)
    response = await make_response(
        send_events(),
        {
            'Content-Type': 'text/event-stream',
            'Cache-Control': 'no-cache',
            'Transfer-Encoding': 'chunked',
        },
    )
    response.timeout = None  # Disable the timeout for this streaming response
    return response
 
<script>
        document.addEventListener('DOMContentLoaded', (event) => {
            const eventSource = new EventSource('/sse');
            eventSource.onmessage = function(event) {
                console.log('New message:', event.data);
                // You can update the DOM here
            };
            eventSource.onopen = function(event) {
                console.log('Connection to server opened.');
            };
            eventSource.onerror = function(event) {
                console.error('EventSource failed.');
            };
            // To close the connection when the window is closed
            window.onbeforeunload = () => {
                eventSource.close();
            };
        });
    </script>
 
With parameters:
from quart import Quart, request, abort, make_response
from dataclasses import dataclass

app = Quart(__name__)

@dataclass
class ServerSentEvent:
data: str
event: str | None = None
id: int | None = None
retry: int | None = None

def encode(self) -> bytes:
message = f"data: {self.data}"
if self.event is not None:
message = f"{message}\nevent: {self.event}"
if self.id is not None:
message = f"{message}\nid: {self.id}"
if self.retry is not None:
message = f"{message}\nretry: {self.retry}"
message = f"{message}\n\n"
return message.encode('utf-8')

@app.get("/chat-updates")
async def chat_updates():
if "text/event-stream" not in request.accept_mimetypes:
abort(400)

friends = request.args.get('friends', default='false') == 'true'
format = request.args.get('format', default='simple')

async def send_events():
while True:
# Your logic to get updates, possibly filtering based on the query parameters
data = ... # Replace with your data retrieval logic
event = ServerSentEvent(data)
yield event.encode()

response = await make_response(
send_events(),
{
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
'Transfer-Encoding': 'chunked',
},
)
response.timeout = None
return response

# Run the app
if __name__ == "__main__":
app.run()
Javascript:
<script>
const params = new URLSearchParams({
friends: 'true',
format: 'detailed'
});

const url = `https://my-server/chat-updates?${params}`;
const eventSource = new EventSource(url);

eventSource.onmessage = function(event) {
// Handle incoming messages
console.log(event.data);
};

eventSource.onerror = function(error) {
// Handle any errors that occur
console.error("EventSource failed:", error);
}; 
</script>
 
// server.js
const http = require('http');
const es = require('event-stream');
// Create a HTTP server
const server = http.createServer((req, res) => {
// Check if the request path is /stream
if (req.url === '/stream') {
// Set the response headers
res.writeHead(200, {
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive'
});
// Create a counter variable
let counter = 0;
// Create an interval function that sends an event every second
const interval = setInterval(() => {
// Increment the counter
counter++;
// Create an event object with name, data, and id properties
const event = {
name: 'message',
data: `Hello, this is message number ${counter}`,
id: counter
};
// Convert the event object to a string
const eventString = `event: ${event.name}\ndata: ${event.data}\nid: ${event.id}\n\n`;
// Write the event string to the response stream
res.write(eventString);
// End the response stream after 10 events
if (counter === 10) {
clearInterval(interval);
res.end();
}
}, 1000);
} else {
// Handle other requests
res.writeHead(404);
res.end('Not found');
}
});
// Listen on port 3000
server.listen(3000, () => {
console.log('Server listening on port 3000');
});
 
// client.js
// Fetch the event stream from the server
fetch('/stream')
.then(response => {
// Get the readable stream from the response body
const stream = response.body;
// Get the reader from the stream
const reader = stream.getReader();
// Define a function to read each chunk
const readChunk = () => {
// Read a chunk from the reader
reader.read()
.then(({
value,
done
}
) =>
{
// Check if the stream is done
if (done) {
// Log a message
console.log('Stream finished');
// Return from the function
return;
}
// Convert the chunk value to a string
const chunkString = new TextDecoder().decode(value);
// Log the chunk string
console.log(chunkString);
// Read the next chunk
readChunk();
})
.catch(error => {
// Log the error
console.error(error);
});
};
// Start reading the first chunk
readChunk();
})
.catch(error => {
// Log the error
console.error(error);
});
  
 
from flask import Flask, Response, render_template
import itertools
import time

app = Flask(__name__)

@app.route('/')
def index():
return render_template('index.html')

@app.route('/connect')
def publish_hello():
def stream():
for idx in itertools.count():
msg = f"data: <p>This is {idx}.</p>\n\n"
yield msg
time.sleep(1)
return Response(stream(), mimetype="text/event-stream")

Htmx

<!DOCTYPE html>
<html>
<head>
<script src="https://unpkg.com/htmx.org@1.8.6"></script>
<script src="https://unpkg.com/htmx.org/dist/ext/sse.js"></script>
</head>
<body>
<div hx-ext="sse" sse-connect="/connect" sse-swap="message">
Contents of this box will be updated in real time with every SSE message received from the server.
</div>
</body>
</html>
 
In this example, the Flask app sends a message to the HTMX client every second. The message is wrapped in an HTML paragraph tag and sent as an SSE event. The HTMX client listens to the SSE endpoint and updates the contents of the HTML element with the sse-swap attribute with the message received from the server.
Streaming data from Flask to HTMX using Server-Side Events (SSE) | mathspp 
 // Client-side Javascript in the HTML 
var targetContainer = document.getElementById("this-div");
var eventSource = new EventSource("/stream");
eventSource.onmessage = function(e) {
targetContainer.innerHTML = e.data;
};

Generator + SSE: So why are Python generators good with SSE? It’s simply because they can keeping looping and yielding data and handing it to the client very seamlessly. Here is a simple Python implementation of SSE in Flask:

@route("/stream")
def stream():
def eventStream():
while True:
# Poll data from the database
# and see if there's a new message
if len(messages) > len(previous_messages):
yield "data:
{}\n\n".format(messages[len(messages)-1)])"

return Response(eventStream(), mimetype="text/event-stream")

This is a simple hypothetical event source that checks if there’s a new inbox message and yield the new message. For the browser to acknowledge a server-sent message, you’ll have to comply to this format:

"data: <any_data>\n\n"

You have the option to also send with the data the event and id.

"id: <any_id>\nevent: <any_message>\ndata: <any_data>\n\n"

Note that the fields do not have to be in any order as long as there is a newline (\n) for each field and two (\n\n) at the end of them. With additional event field, you can have more control how you push data to the browser.

// Client-side Javascript in the HTMLvar targetContainer = document.getElementById("this-div");
var eventSource = new EventSource("/stream");
eventSource.addEventListener = (<any_message>, function(e) {
targetContainer.innerHTML = e.data;

if (e.data > 20) {
targetContainer.style.color = "red";
}
};

This will basically render the DOM with the latest data on the specified event message and change the color to “red” when it exceeds 20.

https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#receiving_events_from_the_server

Warning: When not used over HTTP/2, SSE suffers from a limitation to the maximum number of open connections, which can be especially painful when opening multiple tabs, as the limit is per browser and is set to a very low number (6).
The issue has been marked as "Won't fix" in Chrome and Firefox.
This limit is per browser + domain, which means that you can open 6 SSE connections
across all of the tabs to www.example1.com and another 6 SSE connections to www.example2.com (per Stackoverflow). When using HTTP/2, the maximum number of simultaneous HTTP streams is negotiated between the server and the client (defaults to 100). 

Fields
Each message received has some combination of the following fields, one per line:

event
    A string identifying the type of event described. If this is specified, an event will be dispatched on the browser to the listener for the specified event name; the website source code should use addEventListener() to listen for named events. The onmessage handler is called if no event name is specified for a message.

data
    The data field for the message. When the EventSource receives multiple consecutive lines that begin with data:, it concatenates them, inserting a newline character between each one. Trailing newlines are removed.

id
    The event ID to set the EventSource object's last event ID value.

retry
    The reconnection time. If the connection to the server is lost, the browser will wait for the specified time before attempting to reconnect. This must be an integer, specifying the reconnection time in milliseconds. If a non-integer value is specified, the field is ignored.

All other field names are ignored.

Sunday, November 5, 2023

Select and Delete Duplicates from Sqlite Table

Select duplicates from table PonsApimetaDE with columns DE, meta

SELECT DE, meta, COUNT(*)
FROM PonsApimetaDE
GROUP BY DE, meta
HAVING COUNT(*) > 1

Delete duplicates from table PonsApimetaDE with columns DE, meta

DELETE FROM PonsApimetaDE
WHERE rowid NOT IN (
  SELECT MIN(rowid)
  FROM PonsApimetaDE
  GROUP BY DE, meta
)

Delete duplicates from table

CREATE TABLE temp_table as SELECT DISTINCT * FROM source_table;
DELETE FROM source_table;
INSERT INTO source_table SELECT * FROM temp_table
DROP TABLE temp_table

Create index for table PonsApimetaDE with columns DE, meta

CREATE UNIQUE INDEX "idxuniquemetaDE" ON "PonsApimetaDE" (
  "DE"  ASC,
  "meta"  ASC
)

*****

SELECT * FROM table
WHERE rowid > (
  SELECT MIN(rowid) FROM table p2
  WHERE table.column1 = p2.column1
  AND table.column2 = p2.column2
);

DELETE FROM table
WHERE rowid > (
  SELECT MIN(rowid) FROM table p2
  WHERE table.column1 = p2.column1
  AND table.column2 = p2.column2
);

p2 is an alias for the table table in the subquery. This alias is used to make it easier to reference the table table in the subquery without having to type out the entire table name each time.

The purpose of this DELETE statement is to delete all rows from the table table where the column1 and column2 are the same as other rows, but only if the current row's rowid is greater than the smallest rowid with the same column1 and column2.

Here's a breakdown of the query:

The DELETE FROM table statement tells SQLite to delete all rows from the table table that meet the conditions specified in the WHERE clause.

The WHERE rowid > (subquery) clause restricts the rows to be deleted based on their rowid.

The subquery (SELECT MIN(rowid) FROM table p2 WHERE table.column1 = p2.column1 AND table.column2 = p2.column2) calculates the smallest rowid in the table table that has the same column1 and column2 as the current row.

The p2 alias in the subquery allows us to reference the table table without having to type out the entire table name each time.

In summary, this query will delete all duplicate rows from the table table, leaving only one row per unique combination of column1 and column2.

Saturday, November 4, 2023

Mongoose Custom Validator String or Number

const mongoose = require('mongoose');
const { Schema } = mongoose;

main().catch(err => console.log(err));

async function main() {
  await mongoose.connect('mongodb://127.0.0.1:27017/test');
  // use `await mongoose.connect('mongodb://user:password@127.0.0.1:27017/test');`
//   if your database has auth enabled
}
 
const stringornumbervalidator = function(value) {
  return typeof value === 'string' || typeof value === 'number';
};

const MySchema = new Schema({
  myField: {
    type: Schema.Types.Mixed,
    validate: {
      validator: stringornumbervalidator,
      message: 'Value should be either a string or a number'
    }
  }
});

const MyModel = mongoose.model('MyModel', MySchema);

Python Asynchronous Context Manager PlayGround

class AsyncContextManager:
    global correlationMap
    global requestId
    async def __aenter__(self) -> Literal['Waited']: # enter the async context manager
        print('>Entering the async context manager') # report a message
        await asyncio.sleep(0.05) # block for a moment
        return 'Waited'
    async def __aexit__(self, exc_type, exc, tb) -> Literal['Exited']: # exit the async context manager
        print('>Exiting the async context manager') # send a message
        await asyncio.sleep(0.05) # block for a moment
        return 'Exited'
    async def getresult(self):
        await asyncio.sleep(0.05)
        # print('Running inside the context manager')
        return correlationMap[requestId]
    async def dummyasync() -> Literal['Dummy function']:
        print(f"Dummy function started")
        await asyncio.sleep(0.1)
        return 'Dummy function' 
 
async with AsyncContextManager():
    app.add_background_task(callback)
    app.add_background_task(checkResult)
    while responsefirstcall.text == 'Waiting...':
        correlationMap[requestId] = await AsyncContextManager().getresult()
        print('correlationMap before loop: ' + str(correlationMap[requestId]))
            while correlationMap[requestId] == 'Waiting...':
                await asyncio.sleep(0.2)
                print('checkResult inside while loop: ' + str(response.text[:-1]))
                correlationMap[requestId] = await AsyncContextManager().getresult()
                print('Check result inside while loop: ' + str(correlationMap[requestId][:-1]) + ' ' + str(time.strftime("%A %d:%m:%Y %H:%M:%S UTC%z", time.localtime())))
try:
                            # response: httpx.Response = await client.get(f'http://{externalip}:5000/checkResult')
                            if correlationMap[requestId] != 'Waiting...':
                            # if response.text != 'Waiting...': # print('Not Waiting...')
                                # etransdomain = scripts.etrans.etrans(sourcelang, [targetlang], 'SPD', searchformterm).domain
                                # rows.append('E-Translate domain: ' + etransdomain)
                                rows.append('E-Translate')
                                rows.append(correlationMap[requestId].replace('\n', ''))
                                # rows.append(response.text.replace('\n', ''))
                                print(rows)
                                break
                            # else:
                            #     continue
                        except Exception as exc:
                            print(exc)
                            await asyncio.sleep(0.1)
                            rows.append('E-Translate')
                            rows.append('Error')
                            break
 
if rows: print("list is not empty")

Future

Future is simply an abstraction of value that may be not computed yet and will be available eventually. It's a simple container that only does one thing - whenever the value is set, fire all registered callbacks.

If you want to obtain that value, you register a callback via add_done_callback() method.

But unlike in Promise, the actual computation is done externally - and that external code has to call set_result() method to resolve the future.

Coroutine

Coroutine is the object very similar to Generator.

A generator is typically iterated within for loop. It yields values and, starting from PEP342 acceptance, it receives values.

A coroutine is typically iterated within the event loop in depths of asyncio library. A coroutine yields Future instances. When you are iterating over a coroutine and it yields a future, you shall wait until this future is resolved. After that you shall send the value of future into the coroutine, then you receive another future, and so on.

An await expression is practically identical to yield from expression, so by awaiting other coroutine, you stop until that coroutine has all its futures resolved, and get coroutine's return value. The Future is one-tick iterable and its iterator returns actual Future - that roughly means that await future equals yield from future equals yield future.

Task

Task is Future which has been actually started to compute and is attached to event loop. So it's special kind of Future (class Task is derived from class Future), which is associated with some event loop, and it has some coroutine, which serves as Task executor.

Task is usually created by event loop object: you give a coroutine to the loop, it creates Task object and starts to iterate over that coroutine in manner described above. Once the coroutine is finished, Task's Future is resolved by coroutine's return value.

You see, the task is quite similar to JS Promise - it encapsulates background job and its result.

Coroutine Function and Async Function

Coroutine func is a factory of coroutines, like generator function to generators. Notice the difference between Python's coroutine function and Javascript's async function - JS async function, when called, creates a Promise and its internal generator immediately starts being iterated, while Python's coroutine does nothing, until Task is created upon it.

API Calls In NodeJS Express

Create a new route in express called /getAPIResponse. This route will make a REST API call and return the response as JSON.

app.get('/getAPIResponse', (req, res) => {
    // API code will be here
})

Install request using npm: npm install --save request

Once you have the request module installed, create a file called API_helper.js. This will be wrapper for request module to make API calls. In future if you need to use any other module, you simple need to modify the API_helper.js wrapper and not every where inside the application.

Require the request module inside the API_helper.js. We’ll be returning a promise from the helper method, so here is how the API_helper.js looks :

const request = require('request')

module.exports = {
    /*
    ** This method returns a promise
    ** which gets resolved or rejected based
    ** on the result from the API
    */
    make_API_call : function(url){
        return new Promise((resolve, reject) => {
            request(url, { json: true }, (err, res, body) => {
              if (err) reject(err)
              resolve(body)
            });
        })
    }
}

As seen in the above code, the make_API_call method returns a promise which gets resolved or rejected based on API response.

Require the above module in the app.js file.

// require API_helper.js
const api_helper = require('./API_helper')

Make an API call to the REST API https://jsonplaceholder.typicode.com/todos/1 using api_helper which returns some dummy JSON data.

Here is the app.js file:

const express = require('express')
const api_helper = require('./API_helper')
const app = express()
const port = 3000

/*
* Route to DEMO the API call to a REST API Endpoint 
* REST URL : https://jsonplaceholder.typicode.com/todos/1
*/
app.get('/getAPIResponse', (req, res) => {
    api_helper.make_API_call('https://jsonplaceholder.typicode.com/todos/1')
    .then(response => {
        res.json(response)
    })
    .catch(error => {
        res.send(error)
    })
})

app.listen(port, () => console.log(`App listening on port ${port}!`))

api_helper returns a promise which when resolved returns a JSON or returns an error when rejected.

Save the above changes and restart the server. Point your browser to http://localhost:3000/getAPIResponse and will have the API response returned in the browser.

Wednesday, November 1, 2023

Truthy and Falsy Values in Python

In Python, individual values can evaluate to either True or False. They do not necessarily have to be part of a larger expression to evaluate to a truth value because they already have one that has been determined by the rules of the Python language.

The basic rules are:

  • Values that evaluate to False are considered Falsy.
  • Values that evaluate to True are considered Truthy.

According to the Python Documentation:

Any object can be tested for truth value, for use in an if or while condition or as operand of the Boolean operations below (and, or, not).

Boolean Context

When we use a value as part of a larger expression, or as an if or while condition, we are using it in a boolean context.

You can think of a boolean context as a particular "part" of your code that requires a value to be either True or False to make sense. 

Falsy Values

Sequences and Collections:

  • Empty lists []
  • Empty tuples ()
  • Empty dictionaries {}
  • Empty sets set()
  • Empty strings ""
  • Empty ranges range(0)

Numbers

  • Zero of any numeric type.
  • Integer: 0
  • Float: 0.0
  • Complex: 0j

Constants

  • None
  • False

Falsy values were the reason why there was no output in our initial example when the value of a was zero.

Truthy Values

According to the Python Documentation:

By default, an object is considered true.

Truthy values include:

  • Non-empty sequences or collections (lists, tuples, strings, dictionaries, sets).
  • Numeric values that are not zero.
  • True

The Built-in bool() Function

You can check if a value is either truthy or falsy with the built-in bool() function.

According to the Python Documentation, this function:

Returns a Boolean value, i.e. one of True or False. x (the argument) is converted using the standard truth testing procedure.
>>> bool(5)
True
>>> bool(0)
False
>>> bool([])
False
>>> bool({5, 5})
True
>>> bool(-5)
True
>>> bool(0.0)
False
>>> bool(None)
False
>>> bool(1)
True
>>> bool(range(0))
False
>>> bool(set())
False
>>> bool({5, 6, 2, 5})
True

 

__bool __()

With the special method __bool__(), you can set a "customized" condition that will determine when an object of your class will evaluate to True or False.

According to the Python Documentation:

By default, an object is considered true unless its class defines either a __bool__() method that returns False or a __len__() method that returns zero, when called with the object.

For example, if we have this very simple class:

>>> class Account:
	
	def __init__(self, balance):
		self.balance = balance

You can see that no special methods are defined, so all the objects that you create from this class will always evaluate to True:

>>> account1 = Account(500)
>>> bool(account1)
True
>>> account2 = Account(0)
>>> bool(account2)
True

We can customize this behavior by adding the special method __bool__():

>>> class Account:
	def __init__(self, balance):
		self.balance = balance
		
	def __bool__(self):
		return self.balance > 0

Now, if the account balance is greater than zero, the object will evaluate to True. Otherwise, if the account balance is zero, the object will evaluate to False.

>>> account1 = Account(500)
>>> bool(account1)
True
>>> account2 = Account(0)
>>> bool(account2)
False

💡 Tip: If __bool__() is not defined in the class but the __len__() method is, the value returned by this method will determine if the object is truthy or falsy.

🔹 In Summary

  • Truthy values are values that evaluate to True in a boolean context.
  • Falsy values are values that evaluate to False in a boolean context.
  • Falsy values include empty sequences (lists, tuples, strings, dictionaries, sets), zero in every numeric type, None, and False.
  • Truthy values include non-empty sequences, numbers (except 0 in every numeric type), and basically every value that is not falsy.
  • They can be used to make your code more concise. 

Source: freecodecamp.org