Hi,

One of the problem is, what if someone HATES (like literally is DISGUSTED by) 
Michael's Gremlin-Scala implementation and decides to make their own? Should it 
be called Gremlin-Scala-Cause-I-Hate-Gremlin-Scala?

Marko.

http://markorodriguez.com

On Apr 21, 2016, at 9:10 AM, Stephen Mallette <spmalle...@gmail.com> wrote:

> it would be nice if we had some consistency in the community around naming
> of these things. I think that
> 
> gremlin-php
> gremlin-scala
> gremlin-go
> gremlin-python
> gremlin-whatever
> 
> should be the official Gremlin Language Variant naming patterns. That''s
> especially true if the other parallel thread to this has community
> consensus that these things should become TinkerPop maintained projects.
> 
> 
> 
> On Thu, Apr 21, 2016 at 10:59 AM, Dylan Millikin <dylan.milli...@gmail.com>
> wrote:
> 
>> Hey, gremlin-php being the driver do you mean making some sort of
>> gremlin-php-language library that would then leverage the driver?
>> Any suggestion with naming more than welcome here. natural-gremlin-php?
>> 
>> On Thu, Apr 21, 2016 at 10:52 AM, Marko Rodriguez <okramma...@gmail.com>
>> wrote:
>> 
>>> Hello,
>>> 
>>> So, I had to move the tutorial to 3.2.x+ branch because it uses the new
>>> TraversalSource API. Thus, the new URL for the DRAFT tutorial is here:
>>> 
>>> 
>>> 
>> http://tinkerpop.apache.org/docs/3.2.1-SNAPSHOT/tutorials/gremlin-language-variants/
>>> 
>>> I think this is near complete. Here are some things I would like to add
>>> before calling it quits:
>>> 
>>>        1. I would like to make a head-nod at least to JINI. I didn't
>> feel
>>> that it was worth going into that model in the tutorial. Most people
>> won't
>>> do that.
>>>        2. I would like to work with Mark to make Gremlinpy "compliant"
>>> and then promote Gremlinpy at the end.
>>>        3. I would like to work with Dylan to make Gremlin-PHP
>> "compliant"
>>> and then promote Gremlin-PHP at the end.
>>>        4. Any recommendations you may have… ?
>>> 
>>> Thank you,
>>> Marko.
>>> 
>>> http://markorodriguez.com
>>> 
>>> On Apr 20, 2016, at 5:36 PM, Marko Rodriguez <okramma...@gmail.com>
>> wrote:
>>> 
>>>> Hello,
>>>> 
>>>> I have pure Python talking to GremlinServer now via David Brown's
>>> gremlin-python WebSocket driver.
>>>> 
>>>> 
>>> 
>> http://tinkerpop.apache.org/docs/3.1.3-SNAPSHOT/tutorials/gremlin-language-variants/#using-python-and-gremlin-server
>>>> 
>>>> I haven't updated the text, but you can see the Groovy script that
>>> generates the code. Slicky.
>>>> 
>>>> Here it is in action:
>>>> 
>>>>>>> execfile("/Users/marko/Desktop/gremlin-python.py")
>>>>>>> g = PythonGraphTraversalSource("g")
>>>>>>> 
>> g.V().hasLabel("person").repeat(__.out()).times(2).name[0:2].toList()
>>>> [u'ripple', u'lop']
>>>>>>> m =
>>> g.V().hasLabel("person").repeat(__.out()).times(2).name[0:2].toList()
>>>>>>> type(m)
>>>> <type 'list'>
>>>>>>> g.V().out("created").count().toList()
>>>> [4]
>>>>>>> g.V().out("created").groupCount().by("name").toList()
>>>> [{u'ripple': 1, u'lop': 3}]
>>>>>>> 
>>>> 
>>>> Criznazy,
>>>> Marko.
>>>> 
>>>> http://markorodriguez.com
>>>> 
>>>> On Apr 20, 2016, at 2:25 PM, Marko Rodriguez <okramma...@gmail.com>
>>> wrote:
>>>> 
>>>>> Hi,
>>>>> 
>>>>> I added the pure Python model:
>>>>> 
>>>>> 
>>> 
>> http://tinkerpop.apache.org/docs/3.1.3-SNAPSHOT/tutorials/gremlin-language-variants/#using-python-and-gremlin-server
>>>>> 
>>>>> So this section just ends with a generated String. It would be neat to
>>> show David Brown's python driver library submitted that string and
>> getting
>>> back a result set. Anyone have the patience to set up GremlinServer and
>>> import python driver module and "do the do" ?
>>>>> 
>>>>> Also note the section on "Language Drivers vs. Language Variants."
>>>>> 
>>> 
>> http://tinkerpop.apache.org/docs/3.1.3-SNAPSHOT/tutorials/gremlin-language-variants/
>>> (forgot to a href anchor it -- scroll down)
>>>>> 
>>>>> Finally, here is the generate gremlin-python.py file.
>>>>> 
>>> 
>> https://github.com/apache/incubator-tinkerpop/blob/TINKERPOP-1232/docs/static/resources/gremlin-python.py
>>>>> 
>>>>> Take care,
>>>>> Marko.
>>>>> 
>>>>> http://markorodriguez.com
>>>>> 
>>>>> On Apr 20, 2016, at 1:20 PM, Marko Rodriguez <okramma...@gmail.com>
>>> wrote:
>>>>> 
>>>>>> Hi Dylan,
>>>>>> 
>>>>>>> That's a nice article on Jython. I can confirm that the same can be
>>>>>>> accomplished with PHP. I actually like the script to generate the
>>>>>>> traversal. It's more effort but is more IDE friendly than using
>> magic
>>>>>>> methods.
>>>>>> 
>>>>>> Great. Its still DRAFT so please provide ideas/directions.
>>>>>> 
>>>>>>> To bounce off of the  Python->Gremlin-Groovy(String). How would that
>>> work
>>>>>>> with bindings? For instance how would one write the following groovy
>>> script:
>>>>>>> 
>>>>>>> a = "person";b = "name";c = "marko";
>>>>>>> g.V().has(a, b, c);
>>>>>>> 
>>>>>>> (I think it's important to support multiline queries as the
>>> gremlin-server
>>>>>>> communication overhead is pretty significant)
>>>>>> 
>>>>>> I don't know yet. Perhaps, in Python, you write:
>>>>>> 
>>>>>> g.V().has("#a") to denote that you want the #a-string to be a
>> variable
>>> and thus, the compilation is g.V().has(a). Then its up to the language
>>> driver to determine how bindings are declared.
>>>>>> 
>>>>>> Thoughts?,
>>>>>> Marko.
>>>>>> 
>>>>>> http://markorodriguez.com
>>>>>> 
>>>>>> 
>>>>>>> 
>>>>>>> On Wed, Apr 20, 2016 at 12:09 PM, Marko Rodriguez <
>>> okramma...@gmail.com>
>>>>>>> wrote:
>>>>>>> 
>>>>>>>> Hi,
>>>>>>>> 
>>>>>>>> Here is a published SNAPSHOT DRAFT of what I have so far for the
>>> tutorial.
>>>>>>>> 
>>>>>>>> 
>>> 
>> http://tinkerpop.apache.org/docs/3.1.3-SNAPSHOT/tutorials/gremlin-language-variants/
>>>>>>>> 
>>>>>>>> I've asked Ketrina to do a new graphic for this. It will be CrAzY.
>>>>>>>> 
>>>>>>>> The gremlin-jython.py link is broken as I didn't do a full doc
>>> build. Its
>>>>>>>> here to look at if you are interested:
>>>>>>>> 
>>>>>>>> 
>>> 
>> https://github.com/apache/incubator-tinkerpop/blob/TINKERPOP-1232/docs/static/resources/gremlin-jython.py
>>>>>>>> 
>>>>>>>> Marko.
>>>>>>>> 
>>>>>>>> http://markorodriguez.com
>>>>>>>> 
>>>>>>>> On Apr 19, 2016, at 10:08 PM, 8trk <mark.hender...@8trk.com>
>> wrote:
>>>>>>>> 
>>>>>>>>> Ha. That is very cool. You can easily just rewrite that for PHP
>> and
>>>>>>>> probably Ruby too and have working native interfaces.
>>>>>>>>> 
>>>>>>>>> I updated my Gist to work with your examples. I had to update
>>> Gremlinpy
>>>>>>>> because I didn’t define __ correctly (thanks! this was a fun
>>> challenge).
>>>>>>>>> 
>>>>>>>>> https://gist.github.com/emehrkay/68a9e64789826f6a59e8b5c837dd6ce4
>> <
>>>>>>>> https://gist.github.com/emehrkay/68a9e64789826f6a59e8b5c837dd6ce4>
>>>>>>>>> 
>>>>>>>>> 
>>>>>>>>>> On Apr 19, 2016, at 11:55 PM, Marko Rodriguez <
>>> okramma...@gmail.com>
>>>>>>>> wrote:
>>>>>>>>>> 
>>>>>>>>>> Hi,
>>>>>>>>>> 
>>>>>>>>>>> I think adhering to the Gremlin-Java interface is a great idea
>>> exactly
>>>>>>>> for the reasons that you stated.
>>>>>>>>>>> The main reason that I didn’t map one-to-one with the native
>>> interface
>>>>>>>> is because I wasn’t too sure how to do so, I knew that there was a
>>> lot of
>>>>>>>> method overloading which isn’t possible in either of the languages
>>> that I
>>>>>>>> wrote this in (Python/PHP), and I figured this approach would be
>> more
>>>>>>>> flexible with regard to changes in the language (to make it TP3 all
>>> I had
>>>>>>>> to do was define all of the predicates check for them when they’re
>>> passed
>>>>>>>> into functions).
>>>>>>>>>> 
>>>>>>>>>> Check this out. Here is a Groovy script the generates the Python
>>>>>>>> traversal class.
>>>>>>>>>> 
>>>>>>>>>> 
>> https://gist.github.com/okram/940adc02834a97a7187d3da57cbf3227
>>>>>>>>>>           - super simple.
>>>>>>>>>> 
>>>>>>>>>> Thus, no need to fat finger anything in and you know you have
>> every
>>>>>>>> method implemented. Moreover, every release, just generate the
>>> Python class
>>>>>>>> by running this script in the Gremlin Console. And it just works:
>>>>>>>>>> 
>>>>>>>>>>>>> g.V().has("name","marko")
>>>>>>>>>> g.V().has("name", "marko")
>>>>>>>>>>>>> g.V().has("person","name","marko")
>>>>>>>>>> g.V().has("person", "name", "marko")
>>>>>>>>>>>>> g.V().where(out("knows"))
>>>>>>>>>> g.V().where(__.out("knows"))
>>>>>>>>>>>>> 
>>> g.V()._as("a").out("created")._as("b").where(_as("a").out("knows"))
>>>>>>>>>> 
>> g.V().as("a").out("created").as("b").where(__.as("a").out("knows"))
>>>>>>>>>>>>> g.V().match(_as("a").out("knows")._as("b"),
>>>>>>>> _as("b").out("knows")._as("a"))
>>>>>>>>>> g.V().match(__.as("a").out("knows").as("b"),
>>>>>>>> __.as("b").out("knows").as("a"))
>>>>>>>>>>>>> 
>>>>>>>> 
>>> g.V().hasLabel("person").has("age",gt(30)).out("created","knows").name
>>>>>>>>>> g.V().hasLabel("person").has("age", P.gt(30)).out("created",
>>>>>>>> "knows").values("name")
>>>>>>>>>> 
>>>>>>>>>> 
>>>>>>>>>>> The more that I think about it, I think that Gremlinpy’s aim was
>>> to be
>>>>>>>> able to write Groovy in Python. That is the main reason why I
>> didn’t
>>> choose
>>>>>>>> just straight-up string concatenation — I needed to be able to do
>>> things
>>>>>>>> like if clauses or closures or really compounded queries. (In
>> Gizmo,
>>> my
>>>>>>>> OGM, I’ve built some pretty dense queries to send to the Gremlin
>>> server).
>>>>>>>>>> 
>>>>>>>>>> Yea, the closures are the hard part. I saw that in Python you can
>>> walk
>>>>>>>> the syntax tree of a closure :) … nasty.
>>>>>>>>>> 
>>>>>>>>>>> Your approach is clearly closer to to Gremlin-Java interface and
>>> we
>>>>>>>> should probably use some variant of it going forward. I quickly
>> took
>>> that
>>>>>>>> interface and used Gremlinpy to handle all of the processing as
>> seen
>>> in
>>>>>>>> this gist:
>>>>>>>> https://gist.github.com/emehrkay/68a9e64789826f6a59e8b5c837dd6ce4
>>>>>>>>>> 
>>>>>>>>>> Interesting. See how it does with my auto-code generator. Also, I
>>> want
>>>>>>>> to steal your P, T constructs as I think you do that better in
>>> Gremlinpy.
>>>>>>>>>> 
>>>>>>>>>> Marko.
>>>>>>>>>> 
>>>>>>>>>> http://markorodriguez.com
>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>>>> On Apr 19, 2016, at 10:54 PM, Marko Rodriguez <
>>> okramma...@gmail.com>
>>>>>>>> wrote:
>>>>>>>>>>>> 
>>>>>>>>>>>> Hi,
>>>>>>>>>>>> 
>>>>>>>>>>>> Sweet -- your dev@ mail works now.
>>>>>>>>>>>> 
>>>>>>>>>>>>> I think you are on to something with this code example.
>>> Gremlinpy
>>>>>>>> does this, but a bit differently. It uses Python’s magic methods to
>>>>>>>> dynamically build a linked list.
>>>>>>>>>>>>> 
>>>>>>>>>>>>> So when you do something like
>>>>>>>>>>>>> 
>>>>>>>>>>>>> g = Gremlin()
>>>>>>>>>>>>> g.function()
>>>>>>>>>>>>> 
>>>>>>>>>>>>> It creates simply adds an gremlinpy.gremlin.Function object to
>>> the
>>>>>>>> queue. That object has the parameters to send once the linked list
>> is
>>>>>>>> converted to a string.
>>>>>>>>>>>> 
>>>>>>>>>>>> Why would you create a queue and not just concatenate a String?
>>>>>>>>>>>> 
>>>>>>>>>>>>> Check out the readme for a few more examples (it can do things
>>> like
>>>>>>>> add pre-defined statements to the chain, nesting Gremlin instances,
>>> and
>>>>>>>> manually binding params) https://github.com/emehrkay/gremlinpy <
>>>>>>>> https://github.com/emehrkay/gremlinpy>
>>>>>>>>>>>> 
>>>>>>>>>>>> Ah, parameter bindings. Hmm…
>>>>>>>>>>>> 
>>>>>>>>>>>>> I think that a very simple linked list build with a fluid
>>> interface
>>>>>>>> and few predefined object types may be a good approach to defining
>> a
>>> native
>>>>>>>> way to represent a Gremlin query.
>>>>>>>>>>>>> 
>>>>>>>>>>>>> What do you think?
>>>>>>>>>>>> 
>>>>>>>>>>>> It would be really clean if there was GraphTraversalSource,
>>>>>>>> GraphTraversal, and __ Traversal without any "extra methods." In
>>> Gremlinpy
>>>>>>>> README I see lots of other methods off of "g" that are not
>>> Gremlin-Java
>>>>>>>> methods. It would be cool if it was a direct map of Gremlin-Java
>>> (like
>>>>>>>> Gremlin-Groovy and Gremlin-Scala). Where the only deviations are
>>> things
>>>>>>>> like _in(), _as(), etc and any nifty language tricks like
>> g.V().name
>>> or
>>>>>>>> g.V().out()[0:10]. This way, we instill in the designers that any
>>> Gremlin
>>>>>>>> language variant should be "identical," where (within reason) the
>>> docs for
>>>>>>>> Gremlin-Java are just as useful to Gremlinpy people. Furthermore,
>> by
>>>>>>>> stressing this, we ensure that variants don't deviate and go down
>>> their own
>>>>>>>> syntax/constructs path. For instance, I see g.v(12) instead of
>>> g.V(12).
>>>>>>>> When a Gremlin language variant wants to do something new, we
>> should
>>> argue
>>>>>>>> -- "submit a PR to Gremlin-Java w/ your desired addition" as
>> Apache's
>>>>>>>> Gremlin-Java should be considered the standard/idiomatic
>>> representation of
>>>>>>>> Gremlin.
>>>>>>>>>>>> 
>>>>>>>>>>>> Finally, it would be cool to have a tool that introspected on
>>>>>>>> Gremlin-Java and verified that Gremlinpy had all the methods
>>> implemented.
>>>>>>>> Another thing to stress to language variant designers -- make sure
>>> you are
>>>>>>>> in sync with every version so write a test case that does such
>>>>>>>> introspection.
>>>>>>>>>>>> 
>>>>>>>>>>>> Thoughts?,
>>>>>>>>>>>> Marko.
>>>>>>>>>>>> 
>>>>>>>>>>>> http://markorodriguez.com
>>>>>>>>>>>> 
>>>>>>>>>>>> 
>>>>>>>>>>>> 
>>>>>>>>>>>> 
>>>>>>>>>>>>> 
>>>>>>>>>>>>>> On Apr 19, 2016, at 10:19 PM, Marko Rodriguez <
>>> okramma...@gmail.com>
>>>>>>>> wrote:
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> Hello,
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> Okay, so I got into a groove. Here is
>>>>>>>> Python->Gremlin-Groovy(String). This is pure Python -- nothing
>>> Jython going
>>>>>>>> on here.
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> 
>> https://gist.github.com/okram/4705fed038dde673f4c5323416899992
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> Here it is in action:
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # create a traversal source (stupid class name, I know)
>>>>>>>>>>>>>>>>> g = PythonStringGraphTraversalSource("g")
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # simple warmup
>>>>>>>>>>>>>>>>> g.V().has("name","marko")
>>>>>>>>>>>>>> g.V().has("name", "marko")
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # one has()-method, but varargs parsing is smart
>>>>>>>>>>>>>>>>> g.V().has("person","name","marko")
>>>>>>>>>>>>>> g.V().has("person", "name", "marko")
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # strings and numbers mixed
>>>>>>>>>>>>>>>>> g.V().has("person","age",32)
>>>>>>>>>>>>>> g.V().has("person", "age", 32)
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # nested anonymous traversal
>>>>>>>>>>>>>>>>> g.V().where(out("knows"))
>>>>>>>>>>>>>> g.V().where(__.out("knows"))
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # as() is reserved in Python, so _as() is used.
>>>>>>>>>>>>>>>>> 
>>>>>>>> g.V()._as("a").out("created")._as("b").where(_as("a").out("knows"))
>>>>>>>>>>>>>> 
>>> g.V().as("a").out("created").as("b").where(__.as("a").out("knows"))
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # multi-traversal match()
>>>>>>>>>>>>>>>>> g.V().match(_as("a").out("knows")._as("b"),
>>>>>>>> _as("b").out("knows")._as("a"))
>>>>>>>>>>>>>> g.V().match(__.as("a").out("knows").as("b"),
>>>>>>>> __.as("b").out("knows").as("a"))
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # P-predicates and .name-sugar (attribute access
>> interception)
>>>>>>>>>>>>>>>>> 
>>>>>>>> 
>>> g.V().hasLabel("person").has("age",gt(30)).out("created","knows").name
>>>>>>>>>>>>>> g.V().hasLabel("person").has("age", P.gt(30)).out("created",
>>>>>>>> "knows").values("name")
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # smart about boolean conversion
>>>>>>>>>>>>>>>>> g.V().valueMap(True,"name","age")
>>>>>>>>>>>>>> g.V().valueMap(true, "name", "age")
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> # lambdas -- ghetto as its not a Python lambda, but a Groovy
>>> lambda
>>>>>>>> string
>>>>>>>>>>>>>>>>> g.V().map('it.get().value("name")')
>>>>>>>>>>>>>> g.V().map(it.get().value("name"))
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> What other constructs are there? I think thats it… Everything
>>> else
>>>>>>>> from here is just fat fingering in all the methods. Then, from
>> there
>>> you
>>>>>>>> use David Brown's GremlinClient (
>>>>>>>> https://github.com/davebshow/gremlinclient) to shuffle the string
>>> across
>>>>>>>> the network to GremlinServer and get back results. I suppose there
>>> needs to
>>>>>>>> be some sort of .submit() method ? …. hmmm… wondering if
>>> .next()/hasNext()
>>>>>>>> iterator methods can be used to submit automagically and then it
>>> feels JUST
>>>>>>>> like Gremlin-Java.
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> @Mark: This is what Gremlinpy should do, no?
>>>>>>>>>>>>>> @Dylan: Can you find any Gremlin syntax hole I'm missing that
>>> isn't
>>>>>>>> solvable with the current espoused pattern?
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> Good, right?
>>>>>>>>>>>>>> Marko.
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> http://markorodriguez.com
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> On Apr 19, 2016, at 4:51 PM, Marko Rodriguez <
>>> okramma...@gmail.com>
>>>>>>>> wrote:
>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> Hi,
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> Done for the night. Here is PythonStringGraphTraversal.
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> 
>>> https://gist.github.com/okram/4705fed038dde673f4c5323416899992
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> ??? Cool?
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> Marko.
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> http://markorodriguez.com
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> On Apr 19, 2016, at 4:28 PM, Marko Rodriguez <
>>> okramma...@gmail.com>
>>>>>>>> wrote:
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> Hi,
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> So I "learned" Python and am able to do a Python class
>>> wrapper
>>>>>>>> around GraphTraversal.
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> 
>>>>>>>> https://gist.github.com/okram/1a0c5f6b65a4b70c558537e5eeaad429
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> Its crazy, it "just works" -- with __ static methods and
>> all.
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> The reason I wanted to create a wrapper is because I want
>> to
>>> use
>>>>>>>> Python-specific language constructs and not only Gremlin-Java. What
>>> those
>>>>>>>> specific language constructs are, I don't know as I don't know
>>> Python :).
>>>>>>>> Moreover, this shell of a wrapper will be used for the JNI and
>> String
>>>>>>>> construction models. Right?
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> g = PythonGraphTraversalSource(graph)
>>>>>>>>>>>>>>>>>>> g
>>>>>>>>>>>>>>>> graphtraversalsource[tinkergraph[vertices:6 edges:6],
>>> standard]
>>>>>>>>>>>>>>>>>>> g.V()
>>>>>>>>>>>>>>>> [GraphStep(vertex,[])]
>>>>>>>>>>>>>>>>>>> g.V().toList()
>>>>>>>>>>>>>>>> [v[1], v[2], v[3], v[4], v[5], v[6]]
>>>>>>>>>>>>>>>>>>> g.V().where(__.out("created")).values("name").toList()
>>>>>>>>>>>>>>>> [marko, josh, peter]
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> Even valueMap() which takes var args of different types
>>> works.
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> g.V().valueMap()
>>>>>>>>>>>>>>>> [GraphStep(vertex,[]), PropertyMapStep(value)]
>>>>>>>>>>>>>>>>>>> g.V().valueMap().toList()
>>>>>>>>>>>>>>>> [{name=[marko], age=[29]}, {name=[vadas], age=[27]},
>>> {name=[lop],
>>>>>>>> lang=[java]}, {name=[josh], age=[32]}, {name=[ripple],
>> lang=[java]},
>>>>>>>> {name=[peter], age=[35]}]
>>>>>>>>>>>>>>>>>>> g.V().valueMap("name").toList()
>>>>>>>>>>>>>>>> [{name=[marko]}, {name=[vadas]}, {name=[lop]},
>> {name=[josh]},
>>>>>>>> {name=[ripple]}, {name=[peter]}]
>>>>>>>>>>>>>>>>>>> g.V().valueMap(True,"name").toList()
>>>>>>>>>>>>>>>> [{label=person, name=[marko], id=1}, {label=person,
>>> name=[vadas],
>>>>>>>> id=2}, {label=software, name=[lop], id=3}, {label=person,
>>> name=[josh],
>>>>>>>> id=4}, {label=software, name=[ripple], id=5}, {label=person,
>>> name=[peter],
>>>>>>>> id=6}]
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> Easy peasy lemon squeezy or is there something fundamental
>>> I'm
>>>>>>>> missing?
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> Marko.
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> http://markorodriguez.com
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> On Apr 19, 2016, at 2:58 PM, Marko Rodriguez <
>>>>>>>> okramma...@gmail.com> wrote:
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> Hi,
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> So I downloaded and installed Jython 2.7.0.
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> This how easy it was to get Gremlin working in Jython.
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> import sys
>>>>>>>>>>>>>>>>> 
>>>>>>>> 
>>> 
>> sys.path.append("/Users/marko/software/tinkerpop/tinkerpop3/gremlin-console/target/apache-gremlin-console-3.2.1-SNAPSHOT-standalone/lib/commons-codec-1.9.jar")
>>>>>>>>>>>>>>>>> 
>>>>>>>> 
>>> 
>> sys.path.append("/Users/marko/software/tinkerpop/tinkerpop3/gremlin-console/target/apache-gremlin-console-3.2.1-SNAPSHOT-standalone/lib/commons-configuration-1.10.jar")
>>>>>>>>>>>>>>>>> … lots of jars to add
>>>>>>>>>>>>>>>>> 
>>>>>>>> 
>>> 
>> sys.path.append("/Users/marko/software/tinkerpop/tinkerpop3/gremlin-console/target/apache-gremlin-console-3.2.1-SNAPSHOT-standalone/ext/tinkergraph-gremlin/lib/tinkergraph-gremlin-3.2.1-SNAPSHOT.jar")
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> from org.apache.tinkerpop.gremlin.tinkergraph.structure
>>> import
>>>>>>>> TinkerFactory
>>>>>>>>>>>>>>>>> graph = TinkerFactory.createModern()
>>>>>>>>>>>>>>>>> g = graph.traversal()
>>>>>>>>>>>>>>>>> g
>>>>>>>>>>>>>>>>> g.V().hasLabel("person").out("knows").out("created")
>>>>>>>>>>>>>>>>> 
>>> g.V().hasLabel("person").out("knows").out("created").toList()
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> Then, the output looks like this:
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> from org.apache.tinkerpop.gremlin.tinkergraph.structure
>>>>>>>> import TinkerFactory
>>>>>>>>>>>>>>>>>>>> graph = TinkerFactory.createModern()
>>>>>>>>>>>>>>>>>>>> g = graph.traversal()
>>>>>>>>>>>>>>>>>>>> g
>>>>>>>>>>>>>>>>> graphtraversalsource[tinkergraph[vertices:6 edges:6],
>>> standard]
>>>>>>>>>>>>>>>>>>>> g.V().hasLabel("person").out("knows").out("created")
>>>>>>>>>>>>>>>>> [GraphStep(vertex,[]), HasStep([~label.eq(person)]),
>>>>>>>> VertexStep(OUT,[knows],vertex), VertexStep(OUT,[created],vertex)]
>>>>>>>>>>>>>>>>>>>> 
>>> g.V().hasLabel("person").out("knows").out("created").toList()
>>>>>>>>>>>>>>>>> [v[5], v[3]]
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> Note that, of course, Jython's command line doesn't
>>> auto-iterate
>>>>>>>> traversals. Besides that -- sheez, that was simple.
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> The trick now is to use Jython idioms to make
>>> Gremlin-Jython be
>>>>>>>> comfortable to Python users…
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> Marko.
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> http://markorodriguez.com
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> On Apr 19, 2016, at 11:43 AM, Marko Rodriguez <
>>>>>>>> okramma...@gmail.com> wrote:
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> Hi,
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> So I just pushed:
>>>>>>>>>>>>>>>>>> 
>>>>>>>> 
>>> 
>> https://git1-us-west.apache.org/repos/asf?p=incubator-tinkerpop.git;a=commitdiff;h=0beae616
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> This should help provide the scaffolding for the
>> tutorial.
>>>>>>>> Given that I know nothing about Python, I think my contributions
>>> start to
>>>>>>>> fall off significantly here. :) … Well, I can help and write more
>>> text, I
>>>>>>>> just don't know how to use Jython, Python idioms, Gremlinpy, etc…..
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> @Mark/Dylan: If you want to build the tutorial and look
>> at
>>> it,
>>>>>>>> you simple do:
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>   $ bin/process-docs.sh --dryRun
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> And then for me, the URI to which I point my browser for
>>> the
>>>>>>>> index.html on my local computer is:
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> 
>>>>>>>> 
>>> 
>> file:///Users/marko/software/tinkerpop/tinkerpop3/target/docs/htmlsingle/tutorials/gremlin-language-variants/index.html
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> Marko.
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> http://markorodriguez.com
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> On Apr 19, 2016, at 9:16 AM, Marko Rodriguez <
>>>>>>>> okramma...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> Hello (NOTE: I dropped gremlin-users@),
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> Thank you Stephen. Its crazy how simple that is :D.
>>>>>>>>>>>>>>>>>>> 
>>>>>>>> https://twitter.com/apachetinkerpop/status/722432843360546816
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> So Mark, now your fork's TINKERPOP-1232/ branch and
>>>>>>>> https://github.com/apache/incubator-tinkerpop/tree/TINKERPOP-1232
>>> exist
>>>>>>>> and we can keep them sync'd accordingly as we develop this
>> tutorial.
>>> When
>>>>>>>> we feel that the tutorial is ready for primetime, we will issue a
>> PR
>>> to
>>>>>>>> have it merged into tp31/ (and thus, up merged to master/).
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> Where do we go from here? I think this is a good
>>> opportunity
>>>>>>>> to work both on Gremlinpy and the tutorial. Can we make Gremlinpy
>> as
>>> true
>>>>>>>> to the spirit of "host language embedding" as possible? In doing
>> so,
>>> can we
>>>>>>>> explain how we did it so other language providers can learn the
>> best
>>>>>>>> practices?
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> In the tutorial we have 3 models we want to promote:
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>  1. Jython
>>>>>>>>>>>>>>>>>>>  2. Python JINI
>>>>>>>>>>>>>>>>>>>  3. Python String
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> (1) is easy to knock off. In fact, we should ask Michael
>>>>>>>> Pollmeier for advice here given his work on Gremlin-Scala. (2) --
>> ??
>>> do you
>>>>>>>> know how do this? If so, it should be only fairly more difficult
>>> than (1).
>>>>>>>> Finally, (3) is the big win and where I think most of the work both
>>> in the
>>>>>>>> tutorial and in Gremlinpy will happen.
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> How do you propose we proceed?
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> Thank you,
>>>>>>>>>>>>>>>>>>> Marko.
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> http://markorodriguez.com
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>> On Apr 19, 2016, at 8:24 AM, Stephen Mallette <
>>>>>>>> spmalle...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> ok - done:
>>>>>>>> https://github.com/apache/incubator-tinkerpop/tree/TINKERPOP-1232
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> On Tue, Apr 19, 2016 at 9:41 AM, Marko Rodriguez <
>>>>>>>> okramma...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>> Hello,
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> *** Mark, if you are not on dev@tinkerpop, I would
>>> recommend
>>>>>>>> joining that as I will drop gremlin-users@ from communication on
>>> this
>>>>>>>> ticket from here on out. ***
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> @Stephen: Mark forked the TinkerPop repository to his
>>> GitHub
>>>>>>>> account. I believe he gave you access as well as me.
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> Can you create a new stub tutorial for Mark+Dylan+me?
>>> (Moving
>>>>>>>> forward, I will learn how to do it from your one commit).
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> gremlin-language-variants/
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> After that Mark+Dylan+me will go to town on:
>>>>>>>>>>>>>>>>>>>> https://issues.apache.org/jira/browse/TINKERPOP-1232
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> Thank you,
>>>>>>>>>>>>>>>>>>>> Marko.
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> http://markorodriguez.com
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> Begin forwarded message:
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>>> From: Mark Henderson <nore...@github.com>
>>>>>>>>>>>>>>>>>>>>> Subject: emehrkay added you to incubator-tinkerpop
>>>>>>>>>>>>>>>>>>>>> Date: April 15, 2016 10:04:54 AM MDT
>>>>>>>>>>>>>>>>>>>>> To: "Marko A. Rodriguez" <okramma...@gmail.com>
>>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>>> You can now push to this repository.
>>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>>> ---
>>>>>>>>>>>>>>>>>>>>> View it on GitHub:
>>>>>>>>>>>>>>>>>>>>> https://github.com/emehrkay/incubator-tinkerpop
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>> You received this message because you are subscribed to
>>> the
>>>>>>>> Google Groups "Gremlin-users" group.
>>>>>>>>>>>>>>>>>>>> To unsubscribe from this group and stop receiving
>> emails
>>> from
>>>>>>>> it, send an email to gremlin-users+unsubscr...@googlegroups.com.
>>>>>>>>>>>>>>>>>>>> To view this discussion on the web visit
>>>>>>>> 
>>> 
>> https://groups.google.com/d/msgid/gremlin-users/18A7D2FD-B9B1-4DC9-980B-66A6A8F9C7C8%40gmail.com
>>>>>>>> .
>>>>>>>>>>>>>>>>>>>> For more options, visit
>>> https://groups.google.com/d/optout.
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>> You received this message because you are subscribed to
>>> the
>>>>>>>> Google Groups "Gremlin-users" group.
>>>>>>>>>>>>>>>>>>>> To unsubscribe from this group and stop receiving
>> emails
>>> from
>>>>>>>> it, send an email to gremlin-users+unsubscr...@googlegroups.com.
>>>>>>>>>>>>>>>>>>>> To view this discussion on the web visit
>>>>>>>> 
>>> 
>> https://groups.google.com/d/msgid/gremlin-users/CAA-H43990bN1xrtkL%2BWW4Z%3DKY-bhamBuunpzmYcqVxniyv3NOw%40mail.gmail.com
>>>>>>>> .
>>>>>>>>>>>>>>>>>>>> For more options, visit
>>> https://groups.google.com/d/optout.
>>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>>> 
>>>>>>>>>>>>>> 
>>>>>>>>>>>>> 
>>>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>> 
>>>>>>>>> 
>>>>>>>> 
>>>>>>>> 
>>>>>> 
>>>>> 
>>>> 
>>> 
>>> 
>> 

Reply via email to