gt-api 0.0.4__tar.gz

gt_api-0.0.4/LICENSE

@@ -0,0 +1,13 @@
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                   Version 2, December 2004
+ 
+Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+ 
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. You just DO WHAT THE FUCK YOU WANT TO.

gt_api-0.0.4/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: gt_api
+Version: 0.0.4
+Summary: Geotastic internal API wrapper
+Author-email: Adam Jenca <jenca.adam@gmail.com>
+Maintainer-email: Adam Jenca <jenca.adam@gmail.com>
+License:            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                           Version 2, December 2004
+         
+        Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+        
+        Everyone is permitted to copy and distribute verbatim or modified
+        copies of this license document, and changing it is allowed as long
+        as the name is changed.
+         
+                   DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+          TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+        
+         0. You just DO WHAT THE FUCK YOU WANT TO.
+        
+Project-URL: Homepage, https://github.com/jenca-adam/geotastic_api
+Project-URL: Bug Reports, https://github.com/jenca-adam/geotastic_api/issues
+Project-URL: Source, https://github.com/jenca-adam/geotastic_api
+Keywords: geotastic,api
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pycryptodome
+Requires-Dist: requests
+Requires-Dist: websockets
+Dynamic: license-file
+
+# geotastic-api
+
+## Installation
+
+Not on PyPI yet.
+Requires Python. 
+```
+python3 -m pip install .
+```
+(also installs requirements)
+
+## Usage
+
+### Logging in
+
+Most API requests require logging in. There are two ways to do it: 
+
+1. mail + password
+1. token
+
+#### Mail + Password
+
+```python
+import gt_api
+client=gt_api.Client.login('your.mail@example.com', 'hunter2')
+```
+
+And you're in! The big caveat is that this logs you out of any other sessions, and also causes API costs.
+So for most use cases you want to use tokens.
+
+#### Token
+
+```python
+import gt_api
+client=gt_api.Client('d8f350a3f557adc253f5003a81d3098c06dea93f84edf10e3fabc1d92acd1771')
+```
+
+##### How do I get it?
+
+Go to geotastic and log in with your account.
+Then open the developer tools (F12 or ctrl-shift-i). Then navigate to Storage(Application-&gt;Storage for Chrome)-&gt;Local Storage-&gt;https://geotastic.net/ and scroll down to *token*. Copy the value.
+
+Please note that the token is one per session, so once you log out of the session you got the token from, you'll need to update it.
+#### Without Login
+
+Use `Client(None)`.
+Most functions will not work.
+### Creating a drop group
+
+```python
+map_id=12345
+group = client.create_drop_group(map_id, -12.345, -69.420, 'pe', 'My Drop Group', active=True, bias=5.3)
+print(group["dropGroup"]["id"])
+```
+
+### Listing drop groups
+
+```python
+client.get_drop_groups(12345)
+```
+If you don't own the map, use `get_public_drop_groups()`
+
+### Exporting drops
+
+```python
+client.get_map_drops(12345)
+```
+or
+```python
+client.get_group_drops(12345)
+```
+You DON'T need to own the map or the group.
+
+### Importing drops
+
+```python
+drops=[{"id":1,"style":"streetview","lat":39.28719501248246,"lng":-103.07696260471509,"code":"us","panoId":"Ple0qA2-cNzxc0K-gXgbFA"}]
+client.import_drops(drops, 12345, target_type="map", import_type="merge")
+```
+
+Possible target types are `map` and `group`.
+Possible import types are `merge`, `override` and `update`.
+
+### Lobbies
+
+Lobbies are handled a little differently.
+To create a lobby, use `Lobby.create(token)`.
+To join a lobby, user `Lobby.join(token, lobby_id)`.
+You then add handlers for events coming in from the Lobby socket using the `lobby.add_handler("event")` decorator. The handler for the event "\*" will be called for every event.
+You can send socket messages to the lobby using `lobby.send_message(type, **kwargs)`. The kwargs will be added to the message json.
+You can make lobby api requests using `lobby.lobby_api_request(url, method *args, **kwargs)`. Args and kwargs will be passed to `request.request()`.
+To run the lobby event loop, use `Lobby.run()`
+To disconnect from the lobby, use `Lobby.disconnect()`
+Look at `examples/auto_lobby.py`
+### Other uses
+
+There's loads more I can't be bothered to document. Check the source code.
+
+
+## Contributing
+
+If you'd like to have a feature that's not in the library, just create a github issue and I'll get to it (maybe).
+
+If you'd like to add your own, it's pretty easy. Just use developer tools to check which api calls geotastic is making and then remake them as functions. If the calls are encrypted, use `gt_api.generic.decode_encdata`.
+
+

gt_api-0.0.4/README.md

@@ -0,0 +1,106 @@
+# geotastic-api
+
+## Installation
+
+Not on PyPI yet.
+Requires Python. 
+```
+python3 -m pip install .
+```
+(also installs requirements)
+
+## Usage
+
+### Logging in
+
+Most API requests require logging in. There are two ways to do it: 
+
+1. mail + password
+1. token
+
+#### Mail + Password
+
+```python
+import gt_api
+client=gt_api.Client.login('your.mail@example.com', 'hunter2')
+```
+
+And you're in! The big caveat is that this logs you out of any other sessions, and also causes API costs.
+So for most use cases you want to use tokens.
+
+#### Token
+
+```python
+import gt_api
+client=gt_api.Client('d8f350a3f557adc253f5003a81d3098c06dea93f84edf10e3fabc1d92acd1771')
+```
+
+##### How do I get it?
+
+Go to geotastic and log in with your account.
+Then open the developer tools (F12 or ctrl-shift-i). Then navigate to Storage(Application->Storage for Chrome)->Local Storage->https://geotastic.net/ and scroll down to *token*. Copy the value.
+
+Please note that the token is one per session, so once you log out of the session you got the token from, you'll need to update it.
+#### Without Login
+
+Use `Client(None)`.
+Most functions will not work.
+### Creating a drop group
+
+```python
+map_id=12345
+group = client.create_drop_group(map_id, -12.345, -69.420, 'pe', 'My Drop Group', active=True, bias=5.3)
+print(group["dropGroup"]["id"])
+```
+
+### Listing drop groups
+
+```python
+client.get_drop_groups(12345)
+```
+If you don't own the map, use `get_public_drop_groups()`
+
+### Exporting drops
+
+```python
+client.get_map_drops(12345)
+```
+or
+```python
+client.get_group_drops(12345)
+```
+You DON'T need to own the map or the group.
+
+### Importing drops
+
+```python
+drops=[{"id":1,"style":"streetview","lat":39.28719501248246,"lng":-103.07696260471509,"code":"us","panoId":"Ple0qA2-cNzxc0K-gXgbFA"}]
+client.import_drops(drops, 12345, target_type="map", import_type="merge")
+```
+
+Possible target types are `map` and `group`.
+Possible import types are `merge`, `override` and `update`.
+
+### Lobbies
+
+Lobbies are handled a little differently.
+To create a lobby, use `Lobby.create(token)`.
+To join a lobby, user `Lobby.join(token, lobby_id)`.
+You then add handlers for events coming in from the Lobby socket using the `lobby.add_handler("event")` decorator. The handler for the event "\*" will be called for every event.
+You can send socket messages to the lobby using `lobby.send_message(type, **kwargs)`. The kwargs will be added to the message json.
+You can make lobby api requests using `lobby.lobby_api_request(url, method *args, **kwargs)`. Args and kwargs will be passed to `request.request()`.
+To run the lobby event loop, use `Lobby.run()`
+To disconnect from the lobby, use `Lobby.disconnect()`
+Look at `examples/auto_lobby.py`
+### Other uses
+
+There's loads more I can't be bothered to document. Check the source code.
+
+
+## Contributing
+
+If you'd like to have a feature that's not in the library, just create a github issue and I'll get to it (maybe).
+
+If you'd like to add your own, it's pretty easy. Just use developer tools to check which api calls geotastic is making and then remake them as functions. If the calls are encrypted, use `gt_api.generic.decode_encdata`.
+
+

gt_api-0.0.4/gt_api/__init__.py

@@ -0,0 +1,3 @@
+from . import challenge, generic, geo, login, map, misc, season, user
+from .client import Client
+from .lobby import Lobby

gt_api-0.0.4/gt_api/challenge.py

@@ -0,0 +1,48 @@
+from . import generic
+from .client import Client
+
+
+@Client._register_endpoint
+def get_all_user_challenges(auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/challenge/getAllUserChallenges.php",
+            "GET",
+            auth_token,
+        )
+    )
+
+
+@Client._register_endpoint
+def get_challenge_drops(challenge_id, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/challenge/getChallengeDrops.php",
+            "GET",
+            auth_token,
+            params={"id": challenge_id},
+        )
+    )
+
+
+@Client._register_endpoint
+def get_challenge_results(challenge_id, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/challenge/getChallengeResults.php",
+            "GET",
+            auth_token,
+            params={"id": challenge_id},
+        )
+    )
+
+
+@Client._register_endpoint
+def get_own_challenges(auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/challenge/getOwnChallenges.php",
+            "GET",
+            auth_token,
+        )
+    )

gt_api-0.0.4/gt_api/client.py

@@ -0,0 +1,29 @@
+import functools
+from . import login
+
+
+class Client:
+    def __init__(self, auth_token, user_data={}):
+        self.auth_token = auth_token
+        self.user_data = user_data
+
+    def get_user_data(self):
+        return login.login(token=self.auth_token)
+
+    @classmethod
+    def _register_endpoint(cls, endpoint):
+
+        @functools.wraps(endpoint)
+        def replaced(self, *args, **kwargs):
+            return endpoint(*args, **kwargs, auth_token=self.auth_token)
+
+        setattr(cls, endpoint.__name__, replaced)
+        return endpoint
+
+    @classmethod
+    def login(cls, mail, password):
+        login_result = login.login(mail=mail, password=password)
+        return cls(login_result["token"], login_result)
+
+    def __repr__(self):
+        return f"<Client (auth_token={self.auth_token!r})>"

gt_api-0.0.4/gt_api/errors.py

@@ -0,0 +1,6 @@
+class GeotasticAPIError(Exception):
+    pass
+
+
+class LobbyError(GeotasticAPIError):
+    pass

gt_api-0.0.4/gt_api/generic.py

@@ -0,0 +1,85 @@
+import requests, hashlib, os, base64, json
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad, pad
+
+from .errors import GeotasticAPIError
+
+PASSWORD = b"4317969d37f68d4f54eae689d8088eba"  # static
+
+
+def evp_bytes_to_key(salt, password=PASSWORD, key_len=32, iv_len=16):
+    d = b""
+    while len(d) < key_len + iv_len:
+        d_i = (
+            hashlib.md5(d[-16:] + password + salt).digest()
+            if d
+            else hashlib.md5(password + salt).digest()
+        )
+        d += d_i
+
+    return d[:key_len], d[key_len : key_len + iv_len]
+
+
+def aes_decrypt(ct, salt):
+    key, iv = evp_bytes_to_key(salt)
+    cipher = AES.new(key, AES.MODE_CBC, iv)
+    return unpad(cipher.decrypt(ct), AES.block_size)
+
+
+def decode_encdata(plain):
+    encdata = json.loads(plain)
+    ct = base64.b64decode(encdata["ct"])
+    salt = bytes.fromhex(encdata["s"])
+    return json.loads(aes_decrypt(ct, salt))
+
+
+def encode_encdata(data):
+    plain = json.dumps(data).encode("utf-8")
+    salt = os.urandom(8).hex()
+    key, iv = evp_bytes_to_key(bytes.fromhex(salt))
+    cipher = AES.new(key, AES.MODE_CBC, iv)
+    ct = base64.b64encode(cipher.encrypt(pad(plain, AES.block_size))).decode("ascii")
+    return json.dumps({"ct": ct, "iv": iv.hex(), "s": salt})
+
+
+def decode_websocket(payload):
+    decoded = base64.b64decode(payload)
+    if not decoded.startswith(b"Salted__"):
+        raise ValueError("no salt")
+    salt = decoded[8:16]
+    ct = decoded[16:]
+    return json.loads(aes_decrypt(ct, salt))
+
+
+def process_response(response):
+    if response.ok:
+        if not response.content:
+            raise GeotasticAPIError("empty response")
+        json_response = response.json()
+        if json_response["status"] == "success":
+            if json_response.get("enc"):
+                return decode_encdata(json_response["encData"])
+            return json_response.get("data")
+        else:
+            raise GeotasticAPIError(json_response["message"])
+    else:
+        raise GeotasticAPIError(f"{response.status_code} {response.reason}")
+
+
+def geotastic_api_request(
+    url, method, auth_token=None, extra_headers={}, *args, **kwargs
+):
+    # unethical :(
+
+    headers = {"Referer": "https://geotastic.net/", "Origin": "https://geotastic.net"}
+    if auth_token:
+        headers["X-Auth-Token"] = auth_token
+    headers.update(extra_headers)
+    return requests.request(
+        method,
+        url,
+        headers=headers,
+        *args,
+        **kwargs,
+    )

gt_api-0.0.4/gt_api/geo.py

@@ -0,0 +1,20 @@
+from . import generic
+from .client import Client
+
+
+# reverse geocoding
+@Client._register_endpoint
+def reverse(lat, lng, auth_token=None, omit_border_data=True, skip_state_check=False):
+    enc = generic.encode_encdata(
+        {
+            "latLng": {"lat": lat, "lng": lng},
+            "omitBorderData": omit_border_data,
+            "skipStateCheck": skip_state_check,
+        }
+    )
+    response = generic.process_response(
+        generic.geotastic_api_request(
+            "https://api01.geotastic.net/reverseV4", "POST", json={"enc": enc}
+        )
+    )
+    return response

gt_api-0.0.4/gt_api/lobby.py

@@ -0,0 +1,125 @@
+from websockets.sync.client import connect
+from websockets import ConnectionClosed
+from . import generic
+from .errors import LobbyError
+from .client import Client
+import threading
+import json
+
+CLIENT_VERSION = "0.297.17"
+
+
+class Lobby:
+    def __init__(self, connection, auth_token):
+        self.connection = connection
+        self.auth_token = auth_token
+        self.thread = threading.Thread(target=self._event_loop)
+        self.close_reason = "not yet started"
+        self.running = False
+        self.lobby_token = None
+        self.lobby_id = None
+        self.lobby_settings = None
+        self.handlers = {"fullLobby": [self.handle_full_lobby]}
+
+    def event_handler(self, event):
+        def decorator(function):
+            self.handlers.setdefault(event, [])
+            self.handlers[event].append(function)
+            return function
+
+        return decorator
+
+    def feed_event(self, message):
+        for handler in self.handlers.get(message["type"], []) + self.handlers.get(
+            "*", []
+        ):
+            threading.Thread(
+                target=handler,
+                args=(self, message["type"], message.get("data")),
+            ).start()  # run in a separate thread so as to not block the event loop
+
+    def run(self):
+        if self.running:
+            raise RuntimeError("already running")
+        try:
+            ack = generic.decode_websocket(self.connection.recv())
+            self.feed_event(ack)
+        except ConnectionClosed:
+            self.close_reason = self.connection.close_reason
+            raise LobbyError(
+                f"Disconnected by server: {self.connection.close_reason}"
+            ) from None
+        self.running = True
+        self.thread.start()
+
+    def disconnect(self):
+        self.connection.close()
+
+    def lobby_api_request(self, url, method, *args, **kwargs):
+        return generic.geotastic_api_request(
+            url,
+            method,
+            self.auth_token,
+            {"Game-Id": self.lobby_id, "Token": self.lobby_token},
+            *args,
+            **kwargs,
+        )
+
+    def _event_loop(self):
+        while True:
+            try:
+                self.close_reason = self.connection.close_reason
+                message = generic.decode_websocket(self.connection.recv())
+                self.feed_event(message)
+            except ConnectionClosed:
+                self.running = False
+                raise LobbyError(
+                    f"Disconnected by server: {self.connection.close_reason}"
+                ) from None
+
+    def send_message(self, type, **kwargs):
+        if not self.running:
+            raise LobbyError(f"Lobby not running: {self.connection.close_reason}")
+        payload = {
+            "token": self.lobby_token,
+            "gameId": self.lobby_id,
+            "type": type,
+            **kwargs,
+        }
+
+        self.connection.send(json.dumps(payload))
+
+    @classmethod
+    def create(cls, auth_token, server="multiplayer02"):
+        sock = connect(
+            f"wss://{server}.geotastic.net/?client_version={CLIENT_VERSION}&t={auth_token}&a=createNewCustomLobby",
+            origin="https://geotastic.net",
+            subprotocols=["geotastic-protocol"],
+        )
+        return cls(sock, auth_token)
+
+    @classmethod
+    def join(cls, auth_token, lobby_id, name="", server="multiplayer02"):
+        sock = connect(
+            f"wss://{server}.geotastic.net/?client_version={CLIENT_VERSION}&t={auth_token}&la={lobby_id}&n={name}&a=joinLobby",
+            origin="https://geotastic.net",
+            subprotocols=["geotastic-protocol"],
+        )
+        return cls(sock, auth_token)
+
+    def handle_full_lobby(self, lobby, type, message):
+        lobby.lobby_token = message["token"]
+        lobby.lobby_id = message["lobby"]["id"]
+        lobby.lobby_settings = message["lobby"]["settingsOptions"]["settings"]
+
+
+@Client._register_endpoint
+def get_lobby_from_alias(alias, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/lobby/getLobbyFromAlias.php",
+            "GET",
+            auth_token,
+            params={"alias": alias},
+        )
+    )

gt_api-0.0.4/gt_api/login.py

@@ -0,0 +1,30 @@
+from .errors import GeotasticAPIError
+from .generic import decode_encdata
+import requests
+import os
+
+
+def login(mail=None, password=None, token=None, fingerprint=None):
+    if fingerprint is None:
+        fingerprint = os.urandom(16).hex()
+    creds = {}
+    if mail:
+        creds["mail"] = mail
+    if password:
+        creds["password"] = password
+    if token:
+        creds["token"] = token
+    response = requests.post(
+        "https://api.geotastic.net/v1/user/login.php",
+        headers={
+            "Origin": "https://geotastic.net",
+            "Referer": "https://geotastic.net/",
+        },
+        json={"credentials": {"fingerprint": fingerprint, **creds}},
+    )
+    if response.ok:
+        json_response = response.json()
+        if json_response["status"] == "success":
+            return decode_encdata(json_response["encData"])
+        raise GeotasticAPIError(json_response["message"])
+    raise GeotasticAPIError(f"{response.status} {response.reason}")

gt_api-0.0.4/gt_api/map.py

@@ -0,0 +1,260 @@
+from . import generic
+from .client import Client
+
+
+@Client._register_endpoint
+def create_tag(tag_name, auth_token=None):
+    data = generic.encode_encdata({"tag": tag_name})
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/createTagV2.php",
+            "POST",
+            auth_token,
+            json={"enc": data},
+        )
+    )
+
+
+@Client._register_endpoint
+def get_public_drop_groups(map_id, include_tags=True, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/getPublicDropGroups.php",
+            "GET",
+            params={"mapId": map_id, "withTags": include_tags},
+        )
+    )
+
+
+@Client._register_endpoint
+def create_drop_group(
+    map_id, lat, lng, code, title, active=True, bias=1, auth_token=None, **properties
+):
+    data = {
+        "mapId": map_id,
+        "lat": lat,
+        "lng": lng,
+        "code": code,
+        "title": title,
+        "active": active,
+        "bias": bias,
+        "type": "group",
+        **properties,
+    }
+    response = generic.geotastic_api_request(
+        "https://api.geotastic.net/v1/maps/updateDropGroup.php",
+        "POST",
+        auth_token,
+        json=data,
+    )
+    return generic.process_response(response)
+
+
+@Client._register_endpoint
+def update_drop_group(group_id, auth_token=None, **properties):
+    data = {"id": group_id, **properties}
+    response = generic.geotastic_api_request(
+        "https://api.geotastic.net/v1/maps/updateDropGroup.php",
+        "POST",
+        auth_token,
+        json=data,
+    )
+    return generic.process_response(response)
+
+
+@Client._register_endpoint
+def get_drop_groups(map_id, auth_token=None):
+    response = generic.geotastic_api_request(
+        "https://api.geotastic.net/v1/maps/getDropGroups.php",
+        "GET",
+        auth_token,
+        params={"mapId": map_id},
+    )
+    return generic.process_response(response)
+
+
+@Client._register_endpoint
+def delete_drop_group(drop_group_id, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/deleteDropGroupV2.php",
+            "POST",
+            auth_token,
+            json={"dropGroupId": drop_group_id},
+        )
+    )
+
+
+@Client._register_endpoint
+def delete_drop(drop_id, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/deleteDropV2.php",
+            "POST",
+            auth_token,
+            json={"dropId": drop_id},
+        )
+    )
+
+
+@Client._register_endpoint
+def import_drops(drops, target_id, target_type, import_type="merge", auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/drops/importDrops.php",
+            "POST",
+            auth_token,
+            json={
+                "drops": drops,
+                "params": {
+                    "targetId": target_id,
+                    "targetType": target_type,
+                    "importType": import_type,
+                },
+            },
+        )
+    )
+
+
+@Client._register_endpoint
+def get_map_drops(map_id, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/getDrops.php",
+            "GET",
+            auth_token,
+            params={"mapId": map_id},
+        )
+    )
+
+
+@Client._register_endpoint
+def get_group_drops(group_id, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/getDrops.php",
+            "GET",
+            auth_token,
+            params={"groupId": group_id},
+        )
+    )
+
+
+@Client._register_endpoint
+def update_map(map_id, auth_token=None, **properties):
+    data = {"id": map_id, **properties}
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/updateMapV2.php",
+            "POST",
+            auth_token,
+            json={"enc": generic.encode_encdata(data)},
+        )
+    )
+
+
+@Client._register_endpoint
+def delete_map(map_id, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/deleteMap.php",
+            "POST",
+            auth_token,
+            data=str(map_id),
+        )
+    )
+
+
+@Client._register_endpoint
+def get_own_maps(auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/getMaps.php", "GET", auth_token
+        )
+    )
+
+
+@Client._register_endpoint
+def get_playable_maps(auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/getPlayableMaps.php", "GET", auth_token
+        )
+    )
+
+
+@Client._register_endpoint
+def random_single_map_drop(map_id, used_ids=[], auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/getRandomDropFromSingleDropMap.php",
+            "GET",
+            auth_token,
+            params={"mapId": map_id, "usedIds": ",".join(map(str, used_ids))},
+        )
+    )
+
+
+@Client._register_endpoint
+def random_grouped_map_drop(
+    map_id, removed_groups=[], used_ids=[], picker="balanced", auth_token=None
+):
+    response = geotastic_api_request(
+        "https://api.geotastic.net/v1/maps/getRandomDropFromGroupedDropMap.php",
+        "GET",
+        auth_token,
+        params={
+            "mapId": map_id,
+            "rg": ",".join(map(str, removed_groups)),
+            "used": ",".join(map(str, used_ids)),
+            "sm": picker,
+        },
+    )
+    return process_response(response)
+
+
+@Client._register_endpoint
+def get_map_tags(map_id, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/getTagsByMap.php",
+            "GET",
+            auth_token,
+            params={"mapId": map_id},
+        )
+    )
+
+
+@Client._register_endpoint
+def get_maps_by_user(uid, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/getPlayableMapsByUser.php",
+            "GET",
+            auth_token,
+            params={"uid": uid},
+        )
+    )
+
+
+@Client._register_endpoint
+def get_map_info(map_id, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/maps/getPlayableMap.php",
+            "GET",
+            auth_token,
+            params={"id": map_id},
+        )
+    )
+
+
+@Client._register_endpoint
+def increase_play_count(map_id, auth_token=None):
+    response = generic.geotastic_api_request(
+        "https://backend01.geotastic.net/v1/maps/incrementPlayedMapAmountV2.php",
+        "POST",
+        auth_token,
+        json={"enc": generic.encode_encdata({"mapId": map_id})},
+    )
+    return generic.process_response(response)

gt_api-0.0.4/gt_api/misc.py

@@ -0,0 +1,35 @@
+from . import generic
+from .client import Client
+
+
+@Client._register_endpoint
+def get_app_config(auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/config/getAppConfig.php", "GET", auth_token
+        )
+    )
+
+
+@Client._register_endpoint
+def get_community_map_markers(auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/communityMap/getMarkers.php",
+            "GET",
+            auth_token,
+        )
+    )
+
+
+@Client._register_endpoint
+def request_api_key(auth_token=None):
+    data = generic.encode_encdata({})
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/config/requestApiKey.php",
+            "POST",
+            auth_token,
+            json={"enc": data},
+        )
+    )

gt_api-0.0.4/gt_api/season.py

@@ -0,0 +1,11 @@
+from . import generic
+from .client import Client
+
+
+@Client._register_endpoint
+def get_season(auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/season/getSeason.php", "GET", auth_token
+        )
+    )

gt_api-0.0.4/gt_api/user.py

@@ -0,0 +1,59 @@
+from . import generic
+
+from .client import Client
+
+
+@Client._register_endpoint
+def find_users(nickname=None, uid=None, auth_token=None):
+    if not bool(nickname) ^ bool(uid):
+        raise ValueError("Specify exactly one of nickname, uid")
+    params = {"p": "false"}
+    if nickname:
+        params.update({"s": nickname, "t": "nickname"})
+    elif uid:
+        params.udpate({"s": uid, "t": "uid"})
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/user/getUserSuggestions.php",
+            "GET",
+            auth_token,
+            params=params,
+        )
+    )
+
+
+@Client._register_endpoint
+def get_public_user_info(uid, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/user/getPublicUserInfoByUid.php",
+            "GET",
+            auth_token,
+            params={"uid": uid},
+        )
+    )
+
+
+@Client._register_endpoint
+def get_achievements(uid, auth_token=None):
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/user/getAchievementsByUser.php",
+            "GET",
+            auth_token,
+            params={"uid": uid},
+        )
+    )
+
+
+@Client._register_endpoint
+def get_statistics(uid, auth_token=None):
+    data = generic.encode_encdata({"userUid": uid})
+    return generic.process_response(
+        generic.geotastic_api_request(
+            "https://api.geotastic.net/v1/user/getUserStatistics.php",
+            "POST",
+            auth_token,
+            json={"enc": data},
+        )
+    )

gt_api-0.0.4/gt_api.egg-info/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: gt_api
+Version: 0.0.4
+Summary: Geotastic internal API wrapper
+Author-email: Adam Jenca <jenca.adam@gmail.com>
+Maintainer-email: Adam Jenca <jenca.adam@gmail.com>
+License:            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                           Version 2, December 2004
+         
+        Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+        
+        Everyone is permitted to copy and distribute verbatim or modified
+        copies of this license document, and changing it is allowed as long
+        as the name is changed.
+         
+                   DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+          TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+        
+         0. You just DO WHAT THE FUCK YOU WANT TO.
+        
+Project-URL: Homepage, https://github.com/jenca-adam/geotastic_api
+Project-URL: Bug Reports, https://github.com/jenca-adam/geotastic_api/issues
+Project-URL: Source, https://github.com/jenca-adam/geotastic_api
+Keywords: geotastic,api
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pycryptodome
+Requires-Dist: requests
+Requires-Dist: websockets
+Dynamic: license-file
+
+# geotastic-api
+
+## Installation
+
+Not on PyPI yet.
+Requires Python. 
+```
+python3 -m pip install .
+```
+(also installs requirements)
+
+## Usage
+
+### Logging in
+
+Most API requests require logging in. There are two ways to do it: 
+
+1. mail + password
+1. token
+
+#### Mail + Password
+
+```python
+import gt_api
+client=gt_api.Client.login('your.mail@example.com', 'hunter2')
+```
+
+And you're in! The big caveat is that this logs you out of any other sessions, and also causes API costs.
+So for most use cases you want to use tokens.
+
+#### Token
+
+```python
+import gt_api
+client=gt_api.Client('d8f350a3f557adc253f5003a81d3098c06dea93f84edf10e3fabc1d92acd1771')
+```
+
+##### How do I get it?
+
+Go to geotastic and log in with your account.
+Then open the developer tools (F12 or ctrl-shift-i). Then navigate to Storage(Application-&gt;Storage for Chrome)-&gt;Local Storage-&gt;https://geotastic.net/ and scroll down to *token*. Copy the value.
+
+Please note that the token is one per session, so once you log out of the session you got the token from, you'll need to update it.
+#### Without Login
+
+Use `Client(None)`.
+Most functions will not work.
+### Creating a drop group
+
+```python
+map_id=12345
+group = client.create_drop_group(map_id, -12.345, -69.420, 'pe', 'My Drop Group', active=True, bias=5.3)
+print(group["dropGroup"]["id"])
+```
+
+### Listing drop groups
+
+```python
+client.get_drop_groups(12345)
+```
+If you don't own the map, use `get_public_drop_groups()`
+
+### Exporting drops
+
+```python
+client.get_map_drops(12345)
+```
+or
+```python
+client.get_group_drops(12345)
+```
+You DON'T need to own the map or the group.
+
+### Importing drops
+
+```python
+drops=[{"id":1,"style":"streetview","lat":39.28719501248246,"lng":-103.07696260471509,"code":"us","panoId":"Ple0qA2-cNzxc0K-gXgbFA"}]
+client.import_drops(drops, 12345, target_type="map", import_type="merge")
+```
+
+Possible target types are `map` and `group`.
+Possible import types are `merge`, `override` and `update`.
+
+### Lobbies
+
+Lobbies are handled a little differently.
+To create a lobby, use `Lobby.create(token)`.
+To join a lobby, user `Lobby.join(token, lobby_id)`.
+You then add handlers for events coming in from the Lobby socket using the `lobby.add_handler("event")` decorator. The handler for the event "\*" will be called for every event.
+You can send socket messages to the lobby using `lobby.send_message(type, **kwargs)`. The kwargs will be added to the message json.
+You can make lobby api requests using `lobby.lobby_api_request(url, method *args, **kwargs)`. Args and kwargs will be passed to `request.request()`.
+To run the lobby event loop, use `Lobby.run()`
+To disconnect from the lobby, use `Lobby.disconnect()`
+Look at `examples/auto_lobby.py`
+### Other uses
+
+There's loads more I can't be bothered to document. Check the source code.
+
+
+## Contributing
+
+If you'd like to have a feature that's not in the library, just create a github issue and I'll get to it (maybe).
+
+If you'd like to add your own, it's pretty easy. Just use developer tools to check which api calls geotastic is making and then remake them as functions. If the calls are encrypted, use `gt_api.generic.decode_encdata`.
+
+

gt_api-0.0.4/gt_api.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+gt_api/__init__.py
+gt_api/challenge.py
+gt_api/client.py
+gt_api/errors.py
+gt_api/generic.py
+gt_api/geo.py
+gt_api/lobby.py
+gt_api/login.py
+gt_api/map.py
+gt_api/misc.py
+gt_api/season.py
+gt_api/user.py
+gt_api.egg-info/PKG-INFO
+gt_api.egg-info/SOURCES.txt
+gt_api.egg-info/dependency_links.txt
+gt_api.egg-info/requires.txt
+gt_api.egg-info/top_level.txt

gt_api-0.0.4/gt_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gt_api-0.0.4/gt_api.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pycryptodome
+requests
+websockets

gt_api-0.0.4/gt_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+gt_api

gt_api-0.0.4/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+
+[tool.setuptools]
+packages = ["gt_api"]
+
+[project]
+name = "gt_api"
+version = "0.0.4"
+dependencies = [
+	"pycryptodome",
+	"requests",
+	"websockets"
+]
+description = "Geotastic internal API wrapper"
+readme = "README.md"
+license = {file = "LICENSE"}
+keywords = ["geotastic", "api"]
+authors = [{name="Adam Jenca", email="jenca.adam@gmail.com"}]
+maintainers = [{name="Adam Jenca", email="jenca.adam@gmail.com"}]
+classifiers = [
+	"Development Status :: 3 - Alpha",
+	"Programming Language :: Python :: 3 :: Only",
+	"Topic :: Software Development :: Libraries :: Python Modules",
+	"Intended Audience :: Developers",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/jenca-adam/geotastic_api"
+"Bug Reports" = "https://github.com/jenca-adam/geotastic_api/issues"
+"Source" = "https://github.com/jenca-adam/geotastic_api"

gt_api-0.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+