Parse JSON with OOoBasic

Keyboard macros or custom scripts

Parse JSON with OOoBasic

Postby jza » Tue Aug 30, 2016 6:31 am

I wonder if it's possible to parse a JSON object with Basic. The first step would be from converting the JS hash table to a Basic Array. Fortunately they are sort of similar:
Code: Select all   Expand viewCollapse view
JSON_Array = { 1,"two",3,4,5}
Basic_Array = {1, 2, "four", 8}


The issue comes with nested arrays:
Code: Select all   Expand viewCollapse view
{"data":[{"stuff":[
    {"onetype":[
        {"id":1,"name":"John Doe"},
        {"id":2,"name":"Don Joeh"}
    ]},
    {"othertype":[
        {"id":2,"company":"ACME"}
    ]}]
},{"otherstuff":[
    {"thing":
        [[1,42],[2,2]]
    }]
}]}

While basic would be something like this:
Code: Select all   Expand viewCollapse view
Array( Array( 0, 1, 2, 3 ), Array( 42, 0, -42 ), Array( 1 ) )

I am not sure if there is something like a key/value on arrays, as far as I read I could see some samples like this: (A1:A6="red") but I am not sure is the same.
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby JohnSUN-Pensioner » Tue Aug 30, 2016 8:36 am

What about http://extensions.libreoffice.org/exten ... est-plugin ? Or you want fully basic code?
I may not have a lot to give but what I got I'll give to you...
Apache OpenOffice 4.1.4, LibreOffice 5.4.2.2 (x64) on Windows 7
If you think that I did not answer your question, make allowances for my imperfect English
User avatar
JohnSUN-Pensioner
Volunteer
 
Posts: 761
Joined: Fri Jan 14, 2011 1:21 pm
Location: Kyiv, Ukraine

Re: Parse JSON with OOoBasic

Postby Villeroy » Tue Aug 30, 2016 9:55 am

JSON is JavaScript code. Just use it in JavaScript without any parsing. Basic is the worst language to parse anything because it does not have enough libraries for arrays and string manipulation.
Please, edit this topic's initial post and add "[Solved]" to the subject line if your problem has been solved.
Ubuntu 18.04, OpenOffice 4.x & LibreOffice 6.x
User avatar
Villeroy
Volunteer
 
Posts: 25750
Joined: Mon Oct 08, 2007 1:35 am
Location: Germany

Re: Parse JSON with OOoBasic

Postby jza » Tue Aug 30, 2016 10:33 pm

Right but the web uses JSON and XML. So if I want to get data from the web, I should be able to process JSON. And again, it shouldnt be that hard to do string manipulation. Just like Basic is not ideal to parse XML, but uses OOo interfaces to use SAX, DOM, ETC.

But OOo has JS to write macros so I guess I could use a JS macro, just not sure how hard would that be. Oh well.
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby Villeroy » Tue Aug 30, 2016 10:38 pm

JavaScript can be used as a macro language. Learning JavaScript is easier than writing a JavaScript parser in Basic which of course requires that you know JavaScript.
Please, edit this topic's initial post and add "[Solved]" to the subject line if your problem has been solved.
Ubuntu 18.04, OpenOffice 4.x & LibreOffice 6.x
User avatar
Villeroy
Volunteer
 
Posts: 25750
Joined: Mon Oct 08, 2007 1:35 am
Location: Germany

Re: Parse JSON with OOoBasic

Postby jza » Tue Aug 30, 2016 11:35 pm

The issue is not really the language but the libraries or methods that it supports. I am not sure if it can recognize an XHR (XmlHttpRequest) call, to get the json from a remote URL.
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby Villeroy » Tue Aug 30, 2016 11:41 pm

JavaScript is the macro language of your browser. Writing JSON into some kind of database does not require any kind of office suite. This is far, far away from any office suite.
Please, edit this topic's initial post and add "[Solved]" to the subject line if your problem has been solved.
Ubuntu 18.04, OpenOffice 4.x & LibreOffice 6.x
User avatar
Villeroy
Volunteer
 
Posts: 25750
Joined: Mon Oct 08, 2007 1:35 am
Location: Germany

Re: Parse JSON with OOoBasic

Postby jza » Tue Aug 30, 2016 11:48 pm

yes but I am not about building JSON I am about parsing a JSON that was created from a foreign site. So really we are talking more about having the OOo macro JS be able to do requests. I have a basic macro that does this using com.sun.star.ucb.SimpleFileAccess and com.sun.star.io.TextInputStream.
Code: Select all   Expand viewCollapse view
Function getWebService(request As String) As String
Dim sfa As Object, flux As Object, repDoc As Object
Dim repXml As String

sfa = CreateUnoService("com.sun.star.ucb.SimpleFileAccess")
repDoc = CreateUnoService("com.sun.star.io.TextInputStream")
repXml = ""

On Error GoTo badRequest
flux = sfa.openFileRead(request)
repDoc.InputStream = flux
Do while not repDoc.isEOF
  REM repXml = repXml & " " & repDoc.readLine
  repXml = repDoc.readLine
Loop
flux.closeInput
repDoc.closeInput
finished:
getWebService = repXml
Exit Function

I wonder if JS can access a class from Basic?
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby Villeroy » Wed Aug 31, 2016 12:00 am

Basic is a strictly procedural langauge. Basic does not know any classes other than the ones that are exposed by the UNO API. JavaScript can access UNO classes among many other classes and you can define your own classes in JavaScript. With JavaScript you would not even need any office suite on your computer to download a JSON structure and write it to something else. This is completely unrelated to any office suite. OpenOffice and its ugly Basic lingo makes it much more difficult.
Please, edit this topic's initial post and add "[Solved]" to the subject line if your problem has been solved.
Ubuntu 18.04, OpenOffice 4.x & LibreOffice 6.x
User avatar
Villeroy
Volunteer
 
Posts: 25750
Joined: Mon Oct 08, 2007 1:35 am
Location: Germany

Re: Parse JSON with OOoBasic

Postby Villeroy » Wed Aug 31, 2016 1:13 am

The Spanish wikipedia describes very well how easy it is: https://es.wikipedia.org/wiki/JSON
Please, edit this topic's initial post and add "[Solved]" to the subject line if your problem has been solved.
Ubuntu 18.04, OpenOffice 4.x & LibreOffice 6.x
User avatar
Villeroy
Volunteer
 
Posts: 25750
Joined: Mon Oct 08, 2007 1:35 am
Location: Germany

Re: Parse JSON with OOoBasic

Postby jza » Wed Aug 31, 2016 2:53 am

Villeroy wrote:Basic is a strictly procedural langauge. Basic does not know any classes other than the ones that are exposed by the UNO API. JavaScript can access UNO classes among many other classes and you can define your own classes in JavaScript. With JavaScript you would not even need any office suite on your computer to download a JSON structure and write it to something else. This is completely unrelated to any office suite. OpenOffice and its ugly Basic lingo makes it much more difficult.


Right but I assume that UNO will have a great RegEx engine that Basic can use to parse a JSON with nested values. And like I said, this will force the whole macro to change language which is not trivial, since Javascript as oppose to Basic, has to invoke the whole components manually and make it less documented process than inserting data in a spreadsheet.

Most of the examples that I found used XText to insert data as opposed to XSpreadsheet and such.
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby Villeroy » Wed Aug 31, 2016 2:01 pm

Every serious programming language has a regex engine without resorting to an office suite. With JavaScript you do not need any JSON parsing. JavaScript evaluates the JSON string with one function call and then you have all the values in one variable without a single line of further programming. Like any serious programming language (but not Basic), JavaScript supports so called dictionaries (aka associative arrays, hashes). Most JSON objects are dictionaries.

Store a "person" structure with 4 attributes and print out the person name:
Code: Select all   Expand viewCollapse view
var person = {
  Forename:    'John',
  Name:       'Doe',
  Birthday: '2001-01-01',
  City:    'Paris'
};
alert(person.Name);

If the code snippet within the { } is a json file, you open that file and call
Code: Select all   Expand viewCollapse view
person = evaluate(file_handle)

Now everything about that person is in one variable and you can access
person.Name
person.ForeName
person.Birthdate
and person.City
Each of these attributes can easily be written into a connected database or plain text file without any office suite, let alone StarBasic. StarBasic can't do anything at all. StarBasic is a dead language of the 90ies which is useless without office suite. Don't waste your life time with that. Leave that complicated shit behind and program.
Please, edit this topic's initial post and add "[Solved]" to the subject line if your problem has been solved.
Ubuntu 18.04, OpenOffice 4.x & LibreOffice 6.x
User avatar
Villeroy
Volunteer
 
Posts: 25750
Joined: Mon Oct 08, 2007 1:35 am
Location: Germany

Re: Parse JSON with OOoBasic

Postby jza » Wed Aug 31, 2016 2:04 pm

you do know the only tie to JavaScript is the JSON format? but the macro is in basic, not sure what is your goal with the Javascript lesson. Sure I can do it wtihout the office suiet, but now I would need to run extra code outside the macro to be able to make it work. Like a JSONtoCSV, or something like that. Plus Basic also have objects in a similar fashion.

But the question was more to see if Basic could use AOO's Regex engine (SearchRegularExpression, SearchString) so I could get a parsing of the JSON into a more operational Basic data structure.

Honestly I could just use python's json module and just do urllib and json.load() and have a richer reference to AOO code at the same time. But i never really asked about what is JSON and how does Javascript works. So not sure what's this Javascript lesson i am getting.

So you are saying run it outside of the office suite, JS is not really a command line script that I can just run on the terminal, I would need a browser, and kind of beats the porpouse of being a macro, since to run it I would need to open the browser to get the data, to copy it back into the office suite. Did I miss something here?

I'm also givig you the benefit of the doubt and trying to rewrite the macro in JS, but is funny how 10msg later of people telling me to do it in JS, I get 0 answers when asking a JS question related to UNOS's Interfaces
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby Villeroy » Wed Aug 31, 2016 2:36 pm

Write a most simple macro in some language other than Basic because Basic can not parse anything.
Let it open your spreadsheet, insert a new row at the right position and reference the new data row.
Evaluate the JSON string from a temporary file, from the web, from wherever.
Let your trivial spreadsheet macro dump the json values directly into the referenced data row. This is trivial and should be doable with a few lines in JavaScript, BeanShell and Python without writing a JSON parser in an uncapable language from the 90ies.
Please, edit this topic's initial post and add "[Solved]" to the subject line if your problem has been solved.
Ubuntu 18.04, OpenOffice 4.x & LibreOffice 6.x
User avatar
Villeroy
Volunteer
 
Posts: 25750
Joined: Mon Oct 08, 2007 1:35 am
Location: Germany

Re: Parse JSON with OOoBasic

Postby jza » Wed Aug 31, 2016 2:51 pm

Which lines of Javascript? I cant even get XSpreadsheet and XCell.setValue(123) working.
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby Villeroy » Wed Aug 31, 2016 6:51 pm

Tools>Macros>Organize>JavaScript>OpenOffice Macros>ExportSheetsToHTML>exportSheetsToHTML [Edit...]
Please, edit this topic's initial post and add "[Solved]" to the subject line if your problem has been solved.
Ubuntu 18.04, OpenOffice 4.x & LibreOffice 6.x
User avatar
Villeroy
Volunteer
 
Posts: 25750
Joined: Mon Oct 08, 2007 1:35 am
Location: Germany

Re: Parse JSON with OOoBasic

Postby jza » Wed Aug 31, 2016 7:17 pm

I have this code, I keep getting undefined getSheet as not a function. I think I first need to instantiate the ActiveSheet and then the CurrentSelection but none of those functions seems to be recognized.
Code: Select all   Expand viewCollapse view
importClass(Packages.com.sun.star.uno.UnoRuntime);
importClass(Packages.com.sun.star.sheet.XSpreadsheet);
importClass(Packages.com.sun.star.sheet.XSpreadsheets);
importClass(Packages.com.sun.star.sheet.XUsedAreaCursor);
importClass(Packages.com.sun.star.sheet.XSpreadsheetDocument);
importClass(Packages.com.sun.star.sheet.XSheetCellCursor);
importClass(Packages.com.sun.star.table.CellContentType);
importClass(Packages.com.sun.star.table.XCellRange);
importClass(Packages.com.sun.star.table.XCell);
importClass(Packages.com.sun.star.frame.XModel);

oDoc = UnoRuntime.queryInterface(XModel,XSCRIPTCONTEXT.getInvocationContext());
if ( !oDoc )
  oDoc = XSCRIPTCONTEXT.getDocument();
  oSpread = UnoRuntime.queryInterface(XSpreadsheetDocument, oDoc);
  oModel = UnoRuntime.queryInterface(XModel,oDoc);
  oSheetsIndexAccess = UnoRuntime.queryInterface(XIndexAccess, oSpread.getSheets());

oSheet = oDoc.CurrentController.getSheet()
oCell=oSheet.getCurrentSelection();
oCell.setValue(34);


Update: Seems getSheet() was coming from the XSpreadsheetDocument and not the oDoc value. I would only need the one for XCell and XCellRange.
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby RoryOF » Wed Aug 31, 2016 7:32 pm

Should it not be getSheets (plural?)
Apache OpenOffice 4.1.5 on Xubuntu 18.04 (mostly 64 bit version) and infrequently on Win2K/XP
User avatar
RoryOF
Moderator
 
Posts: 27297
Joined: Sat Jan 31, 2009 9:30 pm
Location: Ireland

Re: Parse JSON with OOoBasic

Postby jza » Wed Aug 31, 2016 8:11 pm

Maybe, but maybe I shouldnt use that in that case, and I should look for something like this, here is the sample:
Code: Select all   Expand viewCollapse view
   oCalc = thiscomponent
   osheet = oCalc.CurrentController.ActiveSheet
   oCell = oCalc.getCurrentSelection()
   oCell.Value= 100


How would this be in JS? oDoc = XSCRIPTCONTEXT.getDocument(); works fine but not the rest.
Code: Select all   Expand viewCollapse view
   oSheet = oDoc.CurrentController.ActiveSheet
   oCell=oSheet.getCurrentSelection();
oCell.setValue(34);
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby karolus » Wed Aug 31, 2016 9:45 pm

Hallo

JSON is a common exchange-format for data.
Any serious programming-language is able to read and write json:

python:

Code: Select all   Expand viewCollapse view
import json
help
(json


Karolus
AOO4, Libreoffice - 5.1 … 5.3.2.2 on Linux Mint17
User avatar
karolus
Volunteer
 
Posts: 843
Joined: Sat Jul 02, 2011 9:47 am

Re: Parse JSON with OOoBasic

Postby jza » Wed Aug 31, 2016 10:32 pm

karolus wrote:Hallo

JSON is a common exchange-format for data.
Any serious programming-language is able to read and write json:

Karolus

OMG WHEN did I asked, please explain me what this JSON thing is because I don't know what it is.....
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico

Re: Parse JSON with OOoBasic

Postby karolus » Thu Sep 01, 2016 4:01 am

Hallo

If you know nothing (about JSON) … why do you write basic-shit to parse it?

Here's the output from input above into any python-shell

Code: Select all   Expand viewCollapse view
Help on package json:

NAME
    json

MODULE REFERENCE
    https
://docs.python.org/3.5/library/json.html
    
    The following documentation is automatically generated from the Python
    source files
.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations
.  When in doubt, consult the module reference at the
    location listed above
.

DESCRIPTION
    JSON 
(JavaScript Object Notation) <http://json.org> is a subset of
    JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
    interchange format
.
    
    
:mod:`json` exposes an API familiar to users of the standard library
    
:mod:`marshal` and :mod:`pickle` modules.  It is derived from a
    version of the externally maintained simplejson library
.
    
    Encoding basic Python object hierarchies
::
    
        
>>> import json
        
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
        '["foo", {"bar": ["baz", null, 1.0, 2]}]'
        >>> print(json.dumps("\"foo\bar"))
        "\"foo\bar"
        >>> print(json.dumps('\u1234'))
        "\u1234"
        >>> print(json.dumps('\\'))
        "\\"
        >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
        {"a": 0, "b": 0, "c": 0}
        >>> from io import StringIO
        
>>> io = StringIO()
        >>> json.dump(['streaming API'], io)
        >>> io.getvalue()
        '["streaming API"]'
    
    Compact encoding
::
    
        
>>> import json
        
>>> from collections import OrderedDict
        
>>> mydict = OrderedDict([('4', 5), ('6', 7)])
        >>> json.dumps([1,2,3,mydict], separators=(',', ':'))
        '[1,2,3,{"4":5,"6":7}]'
    
    Pretty printing
::
    
        
>>> import json
        
>>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4))
        {
            "4": 5,
            "6": 7
        
}
    
    Decoding JSON
::
    
        
>>> import json
        
>>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}]
        >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj
        True
        
>>> json.loads('"\\"foo\\bar"') == '"foo\x08ar'
        True
        
>>> from io import StringIO
        
>>> io = StringIO('["streaming API"]')
        >>> json.load(io)[0] == 'streaming API'
        True
    
    Specializing JSON object decoding
::
    
        
>>> import json
        
>>> def as_complex(dct):
        ...     if '__complex__' in dct:
        ...         return complex(dct['real'], dct['imag'])
        ...     return dct
        
...
        >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
        ...     object_hook=as_complex)
        (1+2j)
        >>> from decimal import Decimal
        
>>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')
        True
    
    Specializing JSON object encoding
::
    
        
>>> import json
        
>>> def encode_complex(obj):
        ...     if isinstance(obj, complex):
        ...         return [obj.real, obj.imag]
        ...     raise TypeError(repr(o) + " is not JSON serializable")
        ...
        >>> json.dumps(+ 1j, default=encode_complex)
        '[2.0, 1.0]'
        >>> json.JSONEncoder(default=encode_complex).encode(+ 1j)
        '[2.0, 1.0]'
        >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(+ 1j))
        '[2.0, 1.0]'
    
    
    Using json
.tool from the shell to validate and pretty-print::
    
        $ echo 
'{"json":"obj"}' | python -m json.tool
        
{
            "json": "obj"
        }
        $ echo '{ 1.2:3.4}' | python -m json.tool
        Expecting property name enclosed in double quotes
: line 1 column 3 (char 2)

PACKAGE CONTENTS
    decoder
    encoder
    scanner
    tool

CLASSES
    builtins
.ValueError(builtins.Exception)
        json.decoder.JSONDecodeError
    builtins
.object
        json
.decoder.JSONDecoder
        json
.encoder.JSONEncoder
    
    class JSONDecodeError
(builtins.ValueError)
     |  Subclass of ValueError with the following additional properties:
     |  
     
|  msg: The unformatted error message
     
|  doc: The JSON document being parsed
     
|  pos: The start index of doc where parsing failed
     
|  lineno: The line corresponding to pos
     
|  colno: The column corresponding to pos
     
|  
     
|  Method resolution order:
     |      JSONDecodeError
     
|      builtins.ValueError
     
|      builtins.Exception
     
|      builtins.BaseException
     
|      builtins.object
     
|  
     
|  Methods defined here:
     |  
     
|  __init__(self, msg, doc, pos)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     
|  __reduce__(self)
     |      helper for pickle
     
|  
     
|  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     
|  __weakref__
     
|      list of weak references to the object (if defined)
     |  
     
|  ----------------------------------------------------------------------
     |  Methods inherited from builtins.ValueError:
     |  
     
|  __new__(*args, **kwargs) from builtins.type
     
|      Create and return a new object.  See help(type) for accurate signature.
     |  
     
|  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |  
     
|  __delattr__(self, name, /)
     |      Implement delattr(self, name).
     |  
     
|  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     
|  __repr__(self, /)
     |      Return repr(self).
     |  
     
|  __setattr__(self, name, value, /)
     |      Implement setattr(self, name, value).
     |  
     
|  __setstate__(...)
     |  
     
|  __str__(self, /)
     |      Return str(self).
     |  
     
|  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |  
     
|  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |  
     
|  __cause__
     
|      exception cause
     
|  
     
|  __context__
     
|      exception context
     
|  
     
|  __dict__
     
|  
     
|  __suppress_context__
     
|  
     
|  __traceback__
     
|  
     
|  args
    
    class JSONDecoder
(builtins.object)
     |  Simple JSON <http://json.org> decoder
     |  
     
|  Performs the following translations in decoding by default:
     |  
     
|  +---------------+-------------------+
     |  | JSON          | Python            |
     |  +===============+===================+
     |  | object        | dict              |
     |  +---------------+-------------------+
     |  | array         | list              |
     |  +---------------+-------------------+
     |  | string        | str               |
     |  +---------------+-------------------+
     |  | number (int)  | int               |
     |  +---------------+-------------------+
     |  | number (real) | float             |
     |  +---------------+-------------------+
     |  | true          | True              |
     |  +---------------+-------------------+
     |  | false         | False             |
     |  +---------------+-------------------+
     |  | null          | None              |
     |  +---------------+-------------------+
     |  
     
|  It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
     
|  their corresponding ``float`` values, which is outside the JSON spec.
     |  
     
|  Methods defined here:
     |  
     
|  __init__(self, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)
     |      ``object_hook``, if specified, will be called with the result
     
|      of every JSON object decoded and its return value will be used in
     
|      place of the given ``dict``.  This can be used to provide custom
     
|      deserializations (e.g. to support JSON-RPC class hinting).
     |      
     
|      ``object_pairs_hook``, if specified will be called with the result of
     
|      every JSON object decoded with an ordered list of pairs.  The return
     
|      value of ``object_pairs_hook`` will be used instead of the ``dict``.
     |      This feature can be used to implement custom decoders that rely on the
     
|      order that the key and value pairs are decoded (for example,
     |      collections.OrderedDict will remember the order of insertion). If
     
|      ``object_hook`` is also defined, the ``object_pairs_hook`` takes
     
|      priority.
     |      
     
|      ``parse_float``, if specified, will be called with the string
     
|      of every JSON float to be decoded. By default this is equivalent to
     
|      float(num_str). This can be used to use another datatype or parser
     
|      for JSON floats (e.g. decimal.Decimal).
     |      
     
|      ``parse_int``, if specified, will be called with the string
     
|      of every JSON int to be decoded. By default this is equivalent to
     
|      int(num_str). This can be used to use another datatype or parser
     
|      for JSON integers (e.g. float).
     |      
     
|      ``parse_constant``, if specified, will be called with one of the
     
|      following strings: -Infinity, Infinity, NaN.
     |      This can be used to raise an exception if invalid JSON numbers
     
|      are encountered.
     |      
     
|      If ``strict`` is false (true is the default), then control
     
|      characters will be allowed inside strings.  Control characters in
     
|      this context are those with character codes in the 0-31 range,
     |      including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``.
     |  
     
|  decode(self, s, _w=<built-in method match of _sre.SRE_Pattern object at 0x7f7a2fefe630>)
     |      Return the Python representation of ``s`` (``str`` instance
     
|      containing a JSON document).
     |  
     
|  raw_decode(self, s, idx=0)
     |      Decode a JSON document from ``s`` (``str`` beginning with
     
|      a JSON document) and return a 2-tuple of the Python
     
|      representation and the index in ``s`` where the document ended.
     |      
     
|      This can be used to decode a JSON document from a string that may
     
|      have extraneous data at the end.
     |  
     
|  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     
|  __dict__
     
|      dictionary for instance variables (if defined)
     |  
     
|  __weakref__
     
|      list of weak references to the object (if defined)
    
    class JSONEncoder
(builtins.object)
     |  Extensible JSON <http://json.org> encoder for Python data structures.
     |  
     
|  Supports the following objects and types by default:
     |  
     
|  +-------------------+---------------+
     |  | Python            | JSON          |
     |  +===================+===============+
     |  | dict              | object        |
     |  +-------------------+---------------+
     |  | list, tuple       | array         |
     |  +-------------------+---------------+
     |  | str               | string        |
     |  +-------------------+---------------+
     |  | int, float        | number        |
     |  +-------------------+---------------+
     |  | True              | true          |
     |  +-------------------+---------------+
     |  | False             | false         |
     |  +-------------------+---------------+
     |  | None              | null          |
     |  +-------------------+---------------+
     |  
     
|  To extend this to recognize other objects, subclass and implement a
     
|  ``.default()`` method with another method that returns a serializable
     
|  object for ``o`` if possible, otherwise it should call the superclass
     
|  implementation (to raise ``TypeError``).
     |  
     
|  Methods defined here:
     |  
     
|  __init__(self, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)
     |      Constructor for JSONEncoder, with sensible defaults.
     |      
     
|      If skipkeys is false, then it is a TypeError to attempt
     
|      encoding of keys that are not str, int, float or None.  If
     
|      skipkeys is True, such items are simply skipped.
     |      
     
|      If ensure_ascii is true, the output is guaranteed to be str
     
|      objects with all incoming non-ASCII characters escaped.  If
     
|      ensure_ascii is false, the output can contain non-ASCII characters.
     |      
     
|      If check_circular is true, then lists, dicts, and custom encoded
     
|      objects will be checked for circular references during encoding to
     
|      prevent an infinite recursion (which would cause an OverflowError).
     |      Otherwise, no such check takes place.
     |      
     
|      If allow_nan is true, then NaN, Infinity, and -Infinity will be
     
|      encoded as such.  This behavior is not JSON specification compliant,
     |      but is consistent with most JavaScript based encoders and decoders.
     |      Otherwise, it will be a ValueError to encode such floats.
     |      
     
|      If sort_keys is true, then the output of dictionaries will be
     
|      sorted by key; this is useful for regression tests to ensure
     
|      that JSON serializations can be compared on a day-to-day basis.
     |      
     
|      If indent is a non-negative integer, then JSON array
     
|      elements and object members will be pretty-printed with that
     
|      indent level.  An indent level of 0 will only insert newlines.
     |      None is the most compact representation.
     |      
     
|      If specified, separators should be an (item_separator, key_separator)
     |      tuple.  The default is (', ', ': ') if *indent* is ``None`` and
     
|      (',', ': ') otherwise.  To get the most compact JSON representation,
     |      you should specify (',', ':') to eliminate whitespace.
     |      
     
|      If specified, default is a function that gets called for objects
     
|      that can't otherwise be serialized.  It should return a JSON encodable
     |      version of the object or raise a ``TypeError``.
     |  
     |  default(self, o)
     |      Implement this method in a subclass such that it returns
     |      a serializable object for ``o``, or calls the base implementation
     |      (to raise a ``TypeError``).
     |      
     |      For example, to support arbitrary iterators, you could
     |      implement default like this::
     |      
     |          def default(self, o):
     |              try:
     |                  iterable = iter(o)
     |              except TypeError:
     |                  pass
     |              else:
     |                  return list(iterable)
     |              # Let the base class default method raise the TypeError
     |              return JSONEncoder.default(self, o)
     |  
     |  encode(self, o)
     |      Return a JSON string representation of a Python data structure.
     |      
     |      >>> from json.encoder import JSONEncoder
     |      >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
     |      '
{"foo": ["bar", "baz"]}'
     |  
     |  iterencode(self, o, _one_shot=False)
     |      Encode the given object and yield each string
     |      representation as available.
     |      
     |      For example::
     |      
     |          for chunk in JSONEncoder().iterencode(bigobject):
     |              mysocket.write(chunk)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  item_separator = '
, '
     |  
     |  key_separator = '
: '

FUNCTIONS
    dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
        Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
        ``.write()``-supporting file-like object).
        
        If ``skipkeys`` is true then ``dict`` keys that are not basic types
        (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
        instead of raising a ``TypeError``.
        
        If ``ensure_ascii`` is false, then the strings written to ``fp`` can
        contain non-ASCII characters if they appear in strings contained in
        ``obj``. Otherwise, all such characters are escaped in JSON strings.
        
        If ``check_circular`` is false, then the circular reference check
        for container types will be skipped and a circular reference will
        result in an ``OverflowError`` (or worse).
        
        If ``allow_nan`` is false, then it will be a ``ValueError`` to
        serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
        in strict compliance of the JSON specification, instead of using the
        JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
        
        If ``indent`` is a non-negative integer, then JSON array elements and
        object members will be pretty-printed with that indent level. An indent
        level of 0 will only insert newlines. ``None`` is the most compact
        representation.
        
        If specified, ``separators`` should be an ``(item_separator, key_separator)``
        tuple.  The default is ``('
, ', ': ')`` if *indent* is ``None`` and
        ``('
,', ': ')`` otherwise.  To get the most compact JSON representation,
        you should specify ``('
,', ':')`` to eliminate whitespace.
        
        ``default(obj)`` is a function that should return a serializable version
        of obj or raise TypeError. The default simply raises TypeError.
        
        If *sort_keys* is ``True`` (default: ``False``), then the output of
        dictionaries will be sorted by key.
        
        To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
        ``.default()`` method to serialize additional types), specify it with
        the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.
    
    dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
        Serialize ``obj`` to a JSON formatted ``str``.
        
        If ``skipkeys`` is true then ``dict`` keys that are not basic types
        (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
        instead of raising a ``TypeError``.
        
        If ``ensure_ascii`` is false, then the return value can contain non-ASCII
        characters if they appear in strings contained in ``obj``. Otherwise, all
        such characters are escaped in JSON strings.
        
        If ``check_circular`` is false, then the circular reference check
        for container types will be skipped and a circular reference will
        result in an ``OverflowError`` (or worse).
        
        If ``allow_nan`` is false, then it will be a ``ValueError`` to
        serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
        strict compliance of the JSON specification, instead of using the
        JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
        
        If ``indent`` is a non-negative integer, then JSON array elements and
        object members will be pretty-printed with that indent level. An indent
        level of 0 will only insert newlines. ``None`` is the most compact
        representation.
        
        If specified, ``separators`` should be an ``(item_separator, key_separator)``
        tuple.  The default is ``('
, ', ': ')`` if *indent* is ``None`` and
        ``('
,', ': ')`` otherwise.  To get the most compact JSON representation,
        you should specify ``('
,', ':')`` to eliminate whitespace.
        
        ``default(obj)`` is a function that should return a serializable version
        of obj or raise TypeError. The default simply raises TypeError.
        
        If *sort_keys* is ``True`` (default: ``False``), then the output of
        dictionaries will be sorted by key.
        
        To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
        ``.default()`` method to serialize additional types), specify it with
        the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.
    
    load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
        Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
        a JSON document) to a Python object.
        
        ``object_hook`` is an optional function that will be called with the
        result of any object literal decode (a ``dict``). The return value of
        ``object_hook`` will be used instead of the ``dict``. This feature
        can be used to implement custom decoders (e.g. JSON-RPC class hinting).
        
        ``object_pairs_hook`` is an optional function that will be called with the
        result of any object literal decoded with an ordered list of pairs.  The
        return value of ``object_pairs_hook`` will be used instead of the ``dict``.
        This feature can be used to implement custom decoders that rely on the
        order that the key and value pairs are decoded (for example,
        collections.OrderedDict will remember the order of insertion). If
        ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority.
        
        To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
        kwarg; otherwise ``JSONDecoder`` is used.
    
    loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
        Deserialize ``s`` (a ``str`` instance containing a JSON
        document) to a Python object.
        
        ``object_hook`` is an optional function that will be called with the
        result of any object literal decode (a ``dict``). The return value of
        ``object_hook`` will be used instead of the ``dict``. This feature
        can be used to implement custom decoders (e.g. JSON-RPC class hinting).
        
        ``object_pairs_hook`` is an optional function that will be called with the
        result of any object literal decoded with an ordered list of pairs.  The
        return value of ``object_pairs_hook`` will be used instead of the ``dict``.
        This feature can be used to implement custom decoders that rely on the
        order that the key and value pairs are decoded (for example,
        collections.OrderedDict will remember the order of insertion). If
        ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority.
        
        ``parse_float``, if specified, will be called with the string
        of every JSON float to be decoded. By default this is equivalent to
        float(num_str). This can be used to use another datatype or parser
        for JSON floats (e.g. decimal.Decimal).
        
        ``parse_int``, if specified, will be called with the string
        of every JSON int to be decoded. By default this is equivalent to
        int(num_str). This can be used to use another datatype or parser
        for JSON integers (e.g. float).
        
        ``parse_constant``, if specified, will be called with one of the
        following strings: -Infinity, Infinity, NaN, null, true, false.
        This can be used to raise an exception if invalid JSON numbers
        are encountered.
        
        To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
        kwarg; otherwise ``JSONDecoder`` is used.
        
        The ``encoding`` argument is ignored and deprecated.

DATA
    __all__ = ['
dump', 'dumps', 'load', 'loads', 'JSONDecoder', 'JSONDecod...

VERSION
    2.0.9

AUTHOR
    Bob Ippolito 
<bob@redivi.com>

FILE
    
/usr/lib/python3.5/json/__init__.py
AOO4, Libreoffice - 5.1 … 5.3.2.2 on Linux Mint17
User avatar
karolus
Volunteer
 
Posts: 843
Joined: Sat Jul 02, 2011 9:47 am

Re: Parse JSON with OOoBasic

Postby jza » Thu Sep 01, 2016 4:16 am

I never said nothing about not knowing JSON, the question is how can I parse JSON using Basic, not what is basic, or what is python or how to parse JSON in Javascript or Python. The question is strictly about Basic.
You are not really providing any answers to the question.
AOO 4.1.1 on Arch Linux
User avatar
jza
 
Posts: 239
Joined: Mon Nov 03, 2008 11:33 am
Location: Cancún, Mexico


Return to OpenOffice Basic, Python, BeanShell, JavaScript

Who is online

Users browsing this forum: No registered users and 3 guests