Merge pull request #153 from NavAbility/23Q2/enh/gqlinstallissues

fix sdkCommonGQL install copy

Author: dehann

MANIFEST.in

@@ -0,0 +1 @@
+recursive-include sdkCommonGQL *

Makefile

@@ -14,7 +14,7 @@ release: $(VIRTUAL_ENV_DIR)
 	$(VIRTUAL_ENV_DIR)/bin/$(PYTHON_VERSION) setup.py sdist
 	# Assuming you have twine already in the sdist
 	$(VIRTUAL_ENV_DIR)/bin/pip install twine
-	$(VIRTUAL_ENV_DIR)/bin/twine upload dist/*
+	$(VIRTUAL_ENV_DIR)/bin/twine upload dist/*.tar.gz
 
 docs_cicd:
 	$(PYTHON_VERSION) -m venv venv_docs

docs/_toc.yml

@@ -19,8 +19,8 @@ parts:
   - file: solvers
 - caption: Tutorials
   chapters:
-  - file: nvatutorials
   - file: bigexample
+  - file: nvatutorials
 - caption: Notes and FAQ
   chapters:
   - file: notesfaq

docs/bigexample.md

@@ -5,132 +5,46 @@
 ```python
 from navability.entities import *
 from navability.services import *
-import asyncio
 from uuid import uuid4
 import numpy as np
+# import asyncio
 
 
 userLabel = "[email protected]"
 robotLabel = "TestRobot"
 sessionLabel = "TestHex"
-fgclient = DFGClient(userLabel, robotLabel, sessionLabel)
 
-variables = await listVariablesAsync(fgclient)
+# for private (non-guest) use, get a token after login at app.navability.io, Connect page.
+auth_token = ''
 
-entries = await listBlobEntriesAsync(fgclient, "x1")
+fgclient = DFGClient(userLabel, robotLabel, sessionLabel, auth_token=auth_token)
 
-```
-
-## Legacy Example
-
-This script will create variables and factors, list the graph, and solve the session for SLAM estimates.
-
-> NOTES:
-> * You'll need to start Python using `python -m asyncio` to support the `await` command.
-> * You'll need numpy to run the example.
-
-```python
-from uuid import uuid4
-import numpy as np
-import json
-from navability.entities import (
-    Client,
-    Factor,
-    FactorData,
-    FullNormal,
-    NavAbilityHttpsClient,
-    Pose2Pose2,
-    PriorPose2,
-    Variable,
-    VariableType,
-)
-from navability.services import (
-    addFactor,
-    addVariable,
-    solveSession,
-    ls,
-    lsf,
-    waitForCompletion,
-    getVariable
-)
+variables = listVariables(fgclient)
+# variables = await listVariablesAsync(fgclient)
 
-navability_client = NavAbilityHttpsClient()
-client = Client("Guest", "MyUser", "Session_" + str(uuid4())[0:8])
+# get one of the variables from the graph
+x1 = getVariable(fgclient, 'x1')
+# xl1 = await getVariableAsync(fgclient, 'x1')
+print('The tags on this variable are', x1.tags)
 
-# Create variables x0, x1, and x2
-variables = [
-    Variable("x0", VariableType.Pose2.value),
-    Variable("x1", VariableType.Pose2.value),
-    Variable("x2", VariableType.Pose2.value),
-]
+# which blob entries (list of labels) are there on this variable
+be_labels = listBlobEntries(fgclient, "x1")
+# be_labels = await listBlobEntriesAsync(fgclient, "x1")
 
-# Create factors between them
-factors = [
-        Factor(
-            "x0f1",
-            "PriorPose2",
-            ["x0"],
-            FactorData(
-                fnc=PriorPose2(
-                    Z=FullNormal(mu=np.zeros(3), cov=np.diag([0.1, 0.1, 0.1]))
-                ).dump()  # This is a generator for a PriorPose2
-            ),
-        ),
-        Factor(
-            "x0x1f1",
-            "Pose2Pose2",
-            ["x0", "x1"],
-            FactorData(
-                fnc=Pose2Pose2(
-                    Z=FullNormal(
-                        mu=[1, 1, np.pi / 3], cov=np.diag([0.1, 0.1, 0.1])
-                    )
-                ).dump()  # This is a generator for a PriorPose2
-            ),
-        ),
-        Factor(
-            "x1x2f1",
-            "Pose2Pose2",
-            ["x1", "x2"],
-            FactorData(
-                fnc=Pose2Pose2(
-                    Z=FullNormal(
-                        mu=[1, 1, np.pi / 3], cov=np.diag([0.1, 0.1, 0.1])
-                    )
-                ).dump()  # This is a generator for a PriorPose2
-            ),
-        ),
-    ]
+# fetch fetch one of the blob entries (note not the blob itself yet)
+entry = getBlobEntry(fgclient, "x1", be_labels[0])
 
-# Get the result IDs so we can check on their completion
-print("Adding variables and factors..\r\n")
-variable_results = [await addVariable(navability_client, client, v) for v in variables]
-factor_results = [await addFactor(navability_client, client, f) for f in factors]
-result_ids = variable_results + factor_results
+## fetch binary data blob from one of the blobstores
+store = NavAbilityBlobStore(fgclient.client, userLabel)
+blob = getBlob(store, str(entry.blobId))
+# blob = await getBlobAsync(store, entry.id)
 
-# Wait for them to be inserted if they havent already
-print("Waiting for them to be loaded..\r\n")
-await waitForCompletion(navability_client, result_ids, maxSeconds=120)
+## which neighbors does this variable have
+x1_nei = listNeighbors(fgclient, 'x1')
 
-# Interrogate the graph
-# Get the variables
-print("Listing all the variables and factors in the session:\r\n")
-vs = await ls(navability_client, client)
-print("Variables: " + json.dumps(vs, indent=4, sort_keys=True))
-# Get the factors
-fs = await lsf(navability_client, client)
-print("Factors: " + json.dumps(fs, indent=4, sort_keys=True))
-# There's some pretty neat functionality with searching, but we'll save that for more comprehensive tutorials
+## which factors are there
+fcts = listFactors(fgclient)
 
-# Request a SLAM multimodal solve and wait for the response
-# Note: Guest sessions solve a little slower than usual because they're using some small hardware we put down for community use. Feel free to reach out if you want faster solving.
-print("Requesting that the graph be solved to determine the positions of the variables (poses)...")
-request_id = await solveSession(navability_client, client)
-await waitForCompletion(navability_client, [request_id], maxSeconds=120)
-
-# Get the solves positions of the variables (these are stores in the PPEs structure)
-print("Getting the estimates of the variables (poses)...")
-estimates = {v.label: (await getVariable(navability_client, client, v.label)).ppes['default'].suggested for v in variables}
-print("Solved estimates for the positions:\r\n")
-print(json.dumps(estimates, indent=4, sort_keys=True))
-```
+## get a specific factor
+fc = getFactor(fgclient, 'x1x2f1')
+```

docs/blobs.md

@@ -83,15 +83,11 @@ Adding `Blob` or `BlobEntry`s from the Python SDK are under construction and [ex
 
 It is also possible to push data blobs:
 ```python
-client = NavAbilityHttpsClient()
-blobId = await addBlob(fgclient.client, "testimage.png", imgblob)
+blobId = addBlob(fgclient, "testimage.png", imgblob)
 ```
 
 Remember to add at least one BlobEntry somewhere in your session so that you might find it again in the future, see `addBlobEntry` above.
 
-:::{eval-rst}
-.. autofunction:: navability.entities.NavAbilityHttpsClient
-:::
 
 :::{seealso}
 See [Tutorial 5 from ICRA 2022 for a more in-depth example of working with data blobs](sdkpynb:python/navability-sdk/icra-5-marineexample).

docs/buildgraph.md

@@ -64,53 +64,39 @@ Let's create a `PriorPose2` unary factor with zero mean and a covariance matrix
 ```python
 prior_distribution = FullNormal(mu=np.zeros(3), cov=np.power(np.diag([0.1, 0.1, 0.1]),2))
 result_f0 = addFactor(fgclient, ["x0"], PriorPose2(Z=prior_distribution)) 
-result_f0 = await addFactorAsync(fgclient, ["x0"], PriorPose2(Z=prior_distribution)) 
+# result_f0 = await addFactorAsync(fgclient, ["x0"], PriorPose2(Z=prior_distribution)) 
 ```
 
 ## Odometry Factor
 
 An odometry factor connects two consecutive robot poses `x0` and `x1` together to form a chain.  Here we use a relative factor of type `Pose2Pose2` with a measurement from pose `x0` to `x1` of `(x=1.0,y=0.0,θ=pi/2)`; the robot drove 1 unit forward (in the x direction).  Similarly to the prior we added above, we use a `FullNormal` distribution to represent the odometry with mean and covariance:
 ```python
-result_v = await addVariable(client, context, "x1", VariableType.Pose2)
+result_v = addVariable(fgclient, "x1", VariableType.Pose2)
 print(f"Added x1 with result ID {result_v}")
+
 odo_distribution = FullNormal(mu=[1.0, 0.0, np.pi/2], cov=np.power(np.diag([0.1, 0.1, 0.01]),2))
-result_fac_1 = await addFactor(client, context, ["x0", "x1"], Pose2Pose2(Z=odo_distribution)) 
+result_fac_1 = addFactor(fgclient, ["x0", "x1"], Pose2Pose2(Z=odo_distribution)) 
 print(f"Added factor with result ID {result_fac_1}")
-
-# Wait for it to be loaded.
-await waitForCompletion(client, [result_v, result_fac_1])
 ```
 
 ## Adding Different Sensors
 
 So far we worked with the `Pose2` factor type.  Among others, `NavAbilitySDK` also provides the `Point2` variable and `Pose2Point2BearingRange` factor types, which we will use to represent a landmark sighting in our factor graph.  We will add a landmark `l1` with bearing range measurement of bearing=`(mu=0,sigma=0.03)` `range=(mu=0.5,sigma=0.1)` and continue our robot trajectory by driving around in a square.
 ```python
-results_variables = [
-  await addVariable(client, context, "l1", VariableType.Point2),
-  await addVariable(client, context, "x2", VariableType.Pose2),
-  await addVariable(client, context, "x3", VariableType.Pose2),
-  await addVariable(client, context, "x4", VariableType.Pose2)]
-results_variables
-
-results_factors = [
-  await addFactor(client, context, ["x0", "l1"], Pose2Point2BearingRange(Normal(0.0,0.03), Normal(0.5,0.1))),
-  await addFactor(client, context, ["x1", "x2"], Pose2Pose2(odo_distribution)),
-  await addFactor(client, context, ["x2", "x3"], Pose2Pose2(odo_distribution)),
-  await addFactor(client, context, ["x3", "x4"], Pose2Pose2(odo_distribution)),
-]
-await waitForCompletion(client, results_variables + results_factors)
+addVariable(fgclient, "l1", VariableType.Point2)
+addVariable(fgclient, "x2", VariableType.Pose2)
+addVariable(fgclient, "x3", VariableType.Pose2)
+addVariable(fgclient, "x4", VariableType.Pose2)
+
+addFactor(fgclient, ["x0", "l1"], Pose2Point2BearingRange(Normal(0.0,0.03), Normal(0.5,0.1)))
+addFactor(fgclient, ["x1", "x2"], Pose2Pose2(odo_distribution))
+addFactor(fgclient, ["x2", "x3"], Pose2Pose2(odo_distribution))
+addFactor(fgclient, ["x3", "x4"], Pose2Pose2(odo_distribution))
 ```
 
 ## One Loop-Closure Example
 
 The robot continued its square trajectory to end off where it started.  To illustrate a loop closure, we add another bearing range sighting to from pose `x4` to landmark `l1`, solve the graph and plot the new results: 
 ```python
-result_factor = await addFactor(client, context, ["x4", "l1"], Pose2Point2BearingRange(Normal(0.0,0.03), Normal(0.5,0.1)))
-
-await waitForCompletion(client, [result_factor])
+result_factor = addFactor(fgclient, ["x4", "l1"], Pose2Point2BearingRange(Normal(0.0,0.03), Normal(0.5,0.1)))
 ```
-
-<!-- ```@docs
-waitForCompletion
-NvaSDK.waitForCompletion2
-``` -->

docs/developer.md

@@ -18,4 +18,15 @@ make docs
 make docs_firefox
 ```
 
-The latter also builds the docs.
+The latter also builds the docs.
+
+## Release to PyPi
+
+Have login credentials and push access to pypi.org.
+
+Run
+```
+make release
+```
+
+Do manual release tag on Github.com/NavAbility/NavAbilitySDK.py.

docs/getting-started.md

@@ -43,26 +43,33 @@ Installing from within a Python kernel can also be done using:
 
 # Starting a Python REPL and Importing
 
-To use the NavAbility SDK example in a REPL you need to start it with `asyncio`, i.e. run `python -m asyncio`.  Together with a [virtual environment][py-venv], the entire call becomes:
+To use the NavAbility SDK example in a REPL, together with a [virtual environment][py-venv]
 ```python
-python3 -m asyncio venv /path/to/user/venv
+python3 venv /path/to/user/venv
 ```
 
-If you don't, you'll see `SyntaxError: 'await' outside function`. 
-
 Loading the SDK module:
 ```python
 from navability.entities import *
 from navability.services import *
-import asyncio
 from uuid import uuid4
 import numpy as np
+# import asyncio
 ```
 
 :::{seealso}
 The NavAbility and [Caesar.jl][cjl-docs] design promote distributed factor graph workflows for both edge and cloud usage.  The NavAbilitySDK is part of a larger architecture where both client and server side computations are used.  The rest of this page illustrates usage against the server side data and computations.  Reach out to NavAbility via Slack [![](https://img.shields.io/badge/Invite-Slack-green.svg?style=popout)][slack-invite] or <[email protected]> for more help.
 :::
 
+:::{warning}
+Earlier versions of NavAbilitySDK.py had to be started with  `python -m asyncio`, otherwise you'd see `SyntaxError: 'await' outside function`:
+```python
+# earlier versions of sdk had to be started with asyncio
+python3 -m asyncio venv /path/to/user/venv
+```
+:::
+
+
 [sdk-py]: https://github.com/NavAbility/NavAbilitySDK.py/issues
 [cjl-docs]: https://juliarobotics.org/Caesar.jl/latest/
 [slack-invite]: https://join.slack.com/t/caesarjl/shared_invite/zt-ucs06bwg-y2tEbddwX1vR18MASnOLsw

docs/nvatutorials.md

@@ -1,6 +1,6 @@
 # NavAbility Tutorials
 
-These Tutorials can be read as static pages or be run live via Binder.  Either of the options below should work.
+These Tutorials can be read as static pages, be run live via Binder / locally, or watched through via the YouTube walkthrough videos.
 <!-- ## Run Via NavAbility App
 
 A free tier access to NavAbility servers is provided through the user `[email protected]`.  To learn more about using the guest user, consider trying the [NavAbility Tutorials](https://app.navability.io/get-started/tutorials).
@@ -20,3 +20,7 @@ On the notebook pages, use the Rocket icon in the top right menu bar to launch a
 - [Tutorial 3: Insufficient Data (3D Range-only)](sdkpynb:python/navability-sdk/icra-3-rangeonly)
 - [Tutorial 4: Leveraging (Contradictory) Prior Data](sdkpynb:python/navability-sdk/icra-4-contradictorydata)
 - [Tutorial 5: Marine Data: Entries and Blobs](sdkpynb:python/navability-sdk/icra-5-marineexample)
+
+:::{tip}
+These notebooks are kept in the {NavAbility/Notebooks repo](https://github.com/NavAbility/BinderNotebooks).
+:::

src/navability/services/loader.py

@@ -2,6 +2,7 @@
 import os
 import toml
 import re
+import pathlib
 
 from gql import gql  # used to parse GraphQL queries
 from graphql import GraphQLSyntaxError  # used to handle GraphQL errors
@@ -160,4 +161,5 @@ def detect_cycle(
 
 
 # Load all GraphQL operations from the "sdkCommonGQL" folder and export them
-GQL_FRAGMENTS, GQL_OPERATIONS = get_operations(os.path.join(".", "sdkCommonGQL"))
+GQL_FRAGMENTS, GQL_OPERATIONS = get_operations(os.path.join(pathlib.Path(__file__).parent.parent.parent.parent,"sdkCommonGQL"))
+#   (os.path.join(".", "sdkCommonGQL"))