ha - i can't tell how serious you are being but i get what you're saying.
it's not really something we can impose anyway.  i guess i was thinking
ahead a bit and more about any TinkerPop maintained GLVs (getting tired of
typing Gremlin Language Variants) and their naming pattern.

On Thu, Apr 21, 2016 at 11:13 AM, Marko Rodriguez <okramma...@gmail.com>
wrote:

> 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