indy | 🕵️‍♂️ Find and sweep all the funds | Ecommerce library

Request.BasicAuthentication should be False not True when using custom authentications.

And you don't need to set CustomHeaders.FoldLines as TIdHTTP already disables folding by default (it wasn't disabled by default at the time the other question was posted).

Otherwise, the rest of the code looks fine.

Though, I would suggest specifying TEncoding.UTF8 on the call to LoadFromStream()), eg:

You can do this with simple indexing. First get the bin number in each direction. You don't need np.digitize for evenly spaced bins:

The main problem is that there are sometimes duplicates in indx, indy. For this reason, we cannot simply do:

Thanks for updating your question; I misunderstood and thought you wanted to highlight the medians (straightforward) but it sounds like you actually want the peaks (more complicated). I also thought that this was your code, not an example from https://cran.r-project.org/web/packages/ggridges/vignettes/gallery.html, so I didn't realise the Catalan_elections dataset was publicly available (e.g. from the ggjoy package).

Here is a more relevant solution:

Socket timeouts are applied on a per-byte basis.

If you ask a socket to read N number of bytes, it will return as many bytes as it can, up to N bytes max, from the socket's receive buffer. It can (and frequently does) return fewer bytes, requiring another read to receive the remaining bytes. If a timeout error occurs, it means no bytes at all arrived in time for the current read. There is no way to know why, or whether they ever will arrive.

If you ask a socket to send N number of bytes, it will accept as many bytes as it can, up to N bytes max, into the socket's write buffer. It can (and sometimes does) buffer fewer bytes, requiring another send to buffer the remaining bytes. If a timeout occurs, it means the socket's write buffer has filled up, the receiver is not reading fast enough (or at all) to clear space in the sender's write buffer in time.

If you ask Indy to read/send N number of bytes, it may perform multiple socket reads/sends internally, waiting for all of the expected bytes to be received/sent. So it may have read/sent X number of bytes, where X < N, before the timeout occured. Sure, you could try another read/send again, asking for only the remaining bytes you haven't received/sent yet (N - X), but don't ask for the bytes you already received/sent (X). You might receive/send more bytes, or you might get another timeout, there is no way to know until you try. However, depending on context, it may not be easy/possible to know how many bytes were received/sent before the timeout, so you might not know how many remaining bytes to ask for again. In which case, about all you can sensibly do is just close the TCP connection, reconnect, and resume/start over.

As for your ability to abort a connection quickly, you could move your read/send code to a worker thread, and then Disconnect() the socket from your main proc when needed. That will generally abort any blocking read/send in progress.

MSXML is a COM-based technology. You need to call CoInitialize/Ex() to initialize the COM library in every thread context that accesses COM interfaces. Otherwise, in this case, CoCreateInstance() will fail with a CO_E_NOTINITIALIZED error. Delphi's RTL initializes the COM library for you in the main thread, but you have to do it yourself in worker threads, such as those used by TIdTCPServer.

By default, TIdTCPServer creates a new thread for each client connection. In this case, the easiest place to initialize COM would be in the server's OnConnect event (since the OnExecute event is looped).

Sadly, TWebRequest simply does not expose the client's port, or access to the underlying request/socket needed so you can obtain the client's port manually.

This is a limitation of WebBroker itself, not of Indy (which is one of the available backends that WebBroker can use, via Indy's IdHTTPWebBrowserBridge unit. Indy has access to the client port, but you don't have access to the Indy HTTP server that WebBrowker uses internally).

When using Indy, assuming you are using Indy's default TIdSSLIOHandlerSocketOpenSSL component for SSL/TLS support, then make sure you put the 2 OpenSSL DLLs, ssleay32.dll and libeay32.dll, in the same folder as your EXE. You can get them from here:

https://github.com/IndySockets/OpenSSL-Binaries

Note that TIdSSLIOHandlerSocketOpenSSL only supports up to OpenSSL 1.0.2. If you need to use OpenSSL 1.1.x instead (for TLS 1.3+, etc), then use this SSLIOHandler instead. You will have to obtain the relevant OpenSSL DLLs from elsewhere, or compile them yourself.

Either way, once you decide which SSLIOHandler you want to use, the code is fairly simple:

TIdMessageBuilderHtml supports adding attachments via streams, as well as via files. However, those streams have to remain alive for the duration that the TIdCustomMessageBuilder.Attachments collection is populated, which is not an option in your case since you are looping through DB records one at a time, thus you would only be able to access 1 DB stream at a time.

You could create a local array/list of TMemoryStream objects, and then populate the TMessageBuilderHtml with those streams, but you will end up wasting a lot of memory that way since TIdMessageBuilderHtml would make its own copy of the TMemoryStream data. And there is no way to have TIdMessageBuilderHtml just use your TMemoryStream data as-is in a read-only mode (hmm, I wonder if I should add that feature!).

The reason why your manual TIdAttachmentMemory objects don't work is simply because TIdCustomMessageBuilder.FillMessage() clears the TIdMessage's body before then re-populating it, thus losing your attachments (and various other properties that you are setting manually beforehand).

You would have to add your DB attachments to the TIdMessage after FillMessage() has done its work first. But, then you risk TIdMessageBuilderHtml not setting up the TIdMessage structure properly since it wouldn't know your DB attachments exist.

On a side note, you are not using TIdAttachmentMemory correctly anyway. Do not call its CloseLoadStream() method if you have not called its OpenLoadStream() method first. Calling its LoadFromStream() method is enough in this case (or, you can even pass the TStream to TIdAttachmentMemory's constructor). Do note, however, that you are leaking the TStream returned by dm.GetDataBlbStrm().

So, in this case, you are probably better off simply populating the TIdMessage manually and not use TIdMessageBuilderHtml at all. Or, you could derive a new class from TIdMessageBuilderHtml (or TIdCustomMessageBuilder directly) and override its virtual FillBody() and FillHeaders() methods to take your DB streams into account.