Cool stuff Marko! I'll make sure to reference this from the docs of
the projects I maintain.

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.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>
>>>
>>
>



-- 
David M. Brown
R.A. CulturePlex Lab, Western University

Reply via email to