assuming, the variable jsonStr contains the response from the API, then            
            

write jsonStr ---> {"code":200,"status":"OK","data":...
set object={}.%FromJSON( jsonStr )
write object.data.hijri.date

That's all.

I'm not sure, if I understand your problem correctly...

but if your problem is the terminal width, then you can change the default terminal width from 80 to 132 (Edit --> Window Size) or simply, you use for example PuTTY. Sometimes my PuTTY starts on the left monitor and goes over to the second monitor, so I can see  long lines in its entirety.

If I understand you correctly, all you have to do is a short loop:

ClassMethod Merge(obj...)
{
   set res=obj(1)
   do res.%Remove("NextCursor")
   for i=2:1:obj do res.OptOuts.%Push(obj(i).OptOuts)
   quit res
}

do Merge(json1, json2, json3, ...)

Sorry to say, but your comparsion has some sore points:

a) The very first mistake is, you are comparing programing languages!
This is a disputable attempt because each programing language was created with a specific aim (i.e. use case) in mind. So there are very few languages which can be compared to each other. ObjecStript was created as an Operating-System-and-Database-and-Programing-Language. Nowdays, it's a Database-and-Programming-Language. Python is just a programming language! 

b) The second mistake is, comparing methods with the same name (one may think, they do the same thing) but they have different internal behaviour.

Your Python code reads one line from the file (i.e. characters until the next LF):   
  

line = file.readline()

but your ObjecScript code:

set strBuffer = FileReader.ReadLine(.len, .tSC, .eol)

reads a chunk of data from a stream and tries to extract a line from this chunk (take a look at the source code!). Here you loose (probably) most of the time. 
   
The more comparable statement should have been:

read strBuffer

assuming, the file was opened as   

open filename:"R":0

c) Apart from OS, CPU and Disk (HDD, SSD), where there is no information, did you made both runs under the same buffer state (cold or warm)?

In my opinion you're comparing apples with oranges.

You could start with

select * from %SYS.Task

and look at the TaskClass column, this gives you the entry point for a given task.

The sense of PBKDF2 encryption is, to prevent a decryption or, at least, to make a decryption as difficult as possible!  Why do you want to decrypt an encrypted password? Why just not reset it?

This is not so simple because parts of a namespace could be mapped in more then one database.

But take a look at the %SYS.Namespace class:

do ##class(%SYS.Namespace).GetAllNSInfo("Namespace", .info)

write ##class(%SYS.Namespace).GetGlobalDest(,"aGlobalname")  // gives you the global database for a specific global

write ##class(%SYS.Namespace).GetRoutineDest(,"aRoutinename")  // gives you the global database specific routine

If you want to remove the N-th field, in the your example, "Field8" is the 6-th field, then:

set fields = "Field^Field1^Field3~Field4^Field5^Field6~Field7^Field8^Field8"
set N=6
set $piece(fields, "^", N, N+1) = $piece(fields, "^", N+1)

If you have to work with subfields, you have to get first those subfields in a temporary variable, for example, in the above example, you want to remove "Field3" then do this:

set temp=$piece(fields, "^", 3)  // get the subfields
set N=1
set $piece(temp, "~", N,N+1) = $piece(temp, "~", N+1)
set $piece(fields, "^", 3) = temp // put the subfields back into the outer string

If you want to remove the N-th field, in the your example, "Field8" is the 6-th field, then:

set fields = "Field^Field1^Field3~Field4^Field5^Field6~Field7^Field8^Field8"
set N=6
set $piece(fields, "^", N, N+1) = $piece(fields, "^", N+1)

If you have to work with subfields, you have to get first those subfields in a temporary variable, for example, in the above example, you want to remove "Field3" then do this:

set temp=$piece(fields, "^", 3)  // get the subfields
set N=1
set $piece(temp, "~", N,N+1) = $piece(temp, "~", N+1)
set $piece(fields, "^", 3) = temp // put the subfields back into the outer string

First of all, if you want to transform a hex string into base64 (or whatever), then first you have to say, WHAT IS that hex string?

According to your example

set hexString = "4C5803040101020179C3913EC3BA7C4C580708010101021824584D4C"

the string has 56 hex chars, so if you decode those 56 hex chars, the resulting string could be:
a) 28 eigth bit characters or
b) 14 sixteen bit chars or even
c)  7 characters, each 32 bits wide.

For cases b) and c) you also have to define the endianness (big- or little-endian).

Second, I assume, your hex-string represents 8-bit chars, so we get 28 characters after converting the hex-chars into a string.

Converting to base64 means, you get for every 3 (8bit) chars four printable (8bit) chars.

We add two padding chars to the 28 byte string, so we have 30 chars,  now which are divisible by 3. This gives you  40 base64 encoded characters. But your Base64 encoding has 44 characters, which must be wrong.

Here is a simple and working solution:

Class DC.Util Extends %RegisteredObject
{
/// Hex to Base64
ClassMethod HexToB64(hex)
{
   if $length(hex)#2 zt "ELEN" // trap, two hex chars should make up each byte
   set str=""
   for i=1:2:$length(hex) set str=str_$char($zhex($extract(hex,i,i+1)))
   quit $system.Encryption.Base64Encode(str,1)
}
/// Base64 to Hex
ClassMethod B64ToHex(b64)
{
   set str=$system.Encryption.Base64Decode(b64), hex=""
   for i=1:1:$length(str) set hex=hex_$extract($zhex($ascii(str,i)+256),2,3)
   quit hex
}
}

and a short test

set hexString = "4C5803040101020179C3913EC3BA7C4C580708010101021824584D4C"
set b64String=##class(DC.Util).HexToB64(hexString)
write b64String, !, ##class(DC.Util).B64ToHex(b64String), !,hexString

TFgDBAEBAgF5w5E+w7p8TFgHCAEBAQIYJFhNTA==
4C5803040101020179C3913EC3BA7C4C580708010101021824584D4C
4C5803040101020179C3913EC3BA7C4C580708010101021824584D4C

By the way, if you ever have to check, if a string does contain ASCII chars only (0x00 - 0x7F), there is a simple trick:

if $zconvert(string,"O","UTF8")=string { write "7bit only" } else { write "chars with 8 or more bits" }