def load_json(self, node): data = node["data"] data.pop("_label", None) data.pop("_attrs", None) with self.json_output: self.json_output.clear_output() display(JSON(data))
def widget(self): # This is ugly right now; need to get the labels all the same size stats = ipywidgets.VBox([ ipywidgets.HBox([ ipywidgets.Label("Domain Left Edge", layout=ipywidgets.Layout(width="20%")), display_ytarray(self.ds.domain_left_edge), ]), ipywidgets.HBox([ ipywidgets.Label("Domain Right Edge", layout=ipywidgets.Layout(width="20%")), display_ytarray(self.ds.domain_right_edge), ]), ipywidgets.HBox([ ipywidgets.Label("Domain Width", layout=ipywidgets.Layout(width="20%")), display_ytarray(self.ds.domain_width), ]), ]) # We round-trip through a JSON encoder to recursively convert stuff to lists dumped = json.dumps(self.ds.parameters, cls=NumpyEncoder, sort_keys=True) loaded = json.loads(dumped) out = ipywidgets.Output() with out: display(JSON(loaded, root="Parameters", expanded=False)) return ipywidgets.VBox([stats, out])
def notebook_json(json_object): """Display IPython JSON object in the notebook :param json_object: item to show """ if json_object: display(JSON(json_object))
def figcaption(text, label=" "): display(HTML("<div class=caption><b> Caption: </b> %s</div>" % text.replace('\n', '<br>'))) text = text.replace('<b>',r'\textbf{').replace('</b>','}') #some replacement of HTML formatting text = text.replace('<i>',r'\textit{').replace('</i>','}') text = text.replace('<tt>',r'\texttt{').replace('</tt>','}') display(JSON({'caption': text, 'label':label}),include=["application/json"])
def load_json(self, change): if change.new == change.old: return None # must be copy to prevent changing the object data = dict(change.new.data) data.pop("_label", None) # TODO just remove private and non-serializable with self.json_output: self.json_output.clear_output() display(JSON(data))
def to_styled_class(item, **kwargs): if kwargs.get("json_display") != "raw" and (isinstance(item, dict) or isinstance(item, list)): if kwargs.get("json_display") == "formatted" or kwargs.get( "notebook_app") != "jupyterlab": return _getitem_FormattedJson(item) else: return JSON(item) else: return item
def display(self, line, cell=''): """ Display something using IPython's rich display system. Parameters ---------- -h, --html : load HTML file -i, --image : load JPG or PNG image -j, --json : load JSON file -l, --latex : load LaTeX file -m, --math : load LaTeX math expression -s, --svg : load SVG file -y, --youtube : load YouTube ID Examples -------- %display -i myimage.png %display -m '\Delta x + y^3' %%display -h \"\"\" <ul> <li>This</li> <li>is</li> <li>a list.</li> </ul> \"\"\" Notes ----- %disp is automatically aliased to %display. """ opts, cell = self.parse_options('%s\n%s' % (line, cell), 'h:i:j:l:m:s:y:', ['image=', 'html=', 'json=', 'latex=', 'math=', 'svg=', 'youtube=']) for opt, arg in opts.iteritems(): if opt in ['h', 'html']: return HTML(arg) elif opt in ['i', 'image']: return Image(arg) elif opt in ['j', 'json']: return JSON(arg) elif opt in ['l', 'latex']: return Latex(arg) elif opt in ['m', 'math']: return Math(arg) elif opt in ['s', u's', 'svg']: return SVG(arg) elif opt in ['y', 'youtube']: return YouTubeVideo(arg) # Raise an exception if no options were specified: raise ValueError('Format: [option] <file|URI>')
def fhir_validate(self, line): """Line magic to validate json FHIR resource(s) from iPython kernel.""" args = magic_arguments.parse_argstring(self.fhir_validate, line) with grpc.insecure_channel(self.grpc_target) as channel: stub = wstlservice_pb2_grpc.WhistleServiceStub(channel) (resp, err) = _get_validation(stub, self.shell, args.version, args.input) if err: return err return JSON(str(json_format.MessageToDict(resp)))
def wstl_reset(self, line): """Cell magic to clear all variables and functions from incremental transformation.""" with grpc.insecure_channel(self.grpc_target) as channel: stub = wstlservice_pb2_grpc.WhistleServiceStub(channel) session_id = str(self.shell.history_manager.session_number) req = wstlservice_pb2.DeleteIncrementalSessionRequest( session_id=session_id) try: resp = stub.DeleteIncrementalSessionRequest(req) except grpc.RpcError as rpc_error: return rpc_error else: return JSON(json_format.MessageToDict(resp))
def load_hl7v2_datastore(self, line): """Load parsed HL7v2 massage from the HL7v2 Store specified.""" args = magic_arguments.parse_argstring(self.load_hl7v2_datastore, line) hl7v2_messages = _get_message_from_hl7v2_store( args.api_version, args.project_id, args.region, args.dataset_id, args.hl7v2_store_id, args.filter) if args.dest_file_name: with open(args.dest_file_name, "w") as dest_file: dest_file.write(hl7v2_messages) return "The message was written to {} successfully.".format( args.dest_file_name) return JSON(hl7v2_messages)
def view_tree(file: types_path_and_file_like, path: Tuple = None, **kwargs): """Display YAML header using IPython JSON display repr. This function works in JupyterLab. Parameters ---------- file : filename or file-like object pointing towards / containing an ASDF file. path : tuple representing the lookup path in the yaml/asdf tree kwargs kwargs passed down to JSON constructor Returns ------- IPython.display.JSON JSON object for rich output in JupyterLab Examples -------- Visualize the full tree of an existing ASDF file:: weldx.asdf.utils.view_tree("single_pass_weld_example.asdf") Visualize a specific element in the tree structure by proving the path:: weldx.asdf.utils.view_tree( "single_pass_weld_example.asdf", path=("process",) ) weldx.asdf.utils.view_tree( "single_pass_weld_example.asdf", path=("process", "welding_process") ) """ from IPython.display import JSON if isinstance(file, str): root = file + "/" else: root = "/" yaml_dict = get_yaml_header(file, parse=True) if path: root = root + "/".join(path) yaml_dict = get_path(yaml_dict, path) kwargs["root"] = root return JSON(yaml_dict, **kwargs)
def pprint_json(data): """ Display a tree-like object in a jupyter notebook. Allows for collapsable interactive interaction with data. Args: data: a dictionary or object Based on: https://gist.github.com/jmmshn/d37d5a1be80a6da11f901675f195ca22 """ from IPython.display import JSON, display display(JSON(loads(DisplayEcoder().encode(data))))
def asdf_json_repr(file, path: Tuple = None, **kwargs): """Display YAML header using IPython JSON display repr. This function works in JupyterLab. Parameters ---------- file filename or BytesIO buffer of ASDF file path tuple representing the lookup path in the yaml/asdf tree kwargs kwargs passed down to JSON constructor Returns ------- IPython.display.JSON JSON object for rich output in JupyterLab Examples -------- Visualize the full tree of an existing ASDF file:: weldx.asdf.utils.asdf_json_repr("single_pass_weld_example.asdf") Visualize a specific element in the tree structure by proving the path:: weldx.asdf.utils.asdf_json_repr( "single_pass_weld_example.asdf", path=("process", "welding_process") ) """ from IPython.display import JSON if isinstance(file, str): root = file + "/" else: root = "/" code = get_yaml_header(file) yaml_dict = yaml.load(code, Loader=yaml.BaseLoader) if path: root = root + "/".join(path) yaml_dict = get_path(yaml_dict, path) kwargs["root"] = root return JSON(yaml_dict, **kwargs)
def asdf_json_repr(file, **kwargs): """Display YAML header using IPython JSON display repr. This function works in JupyterLab. Parameters ---------- file filename or BytesIO buffer of ASDF file kwargs kwargs passed down to JSON constructor Returns ------- IPython.display.JSON JSON object for rich output in JupyterLab """ code = _get_yaml_header(file) yaml_dict = yaml.load(code, Loader=yaml.BaseLoader) return JSON(yaml_dict, **kwargs)
def load_hl7v2_gcs(self, line): """Load and return parsed HL7v2 massage from the blob in a GCS bucket specified.""" args = magic_arguments.parse_argstring(self.load_hl7v2_gcs, line) dest_file_name = args.dest_file_name storage_client = storage.Client() bucket = storage_client.bucket(args.bucket_name) if not bucket.exists(): raise ValueError( "The bucket does not exist. Please check the provided bucket name." ) blob = bucket.get_blob(args.source_blob_name) if not blob: raise ValueError( "The blob does not exist. Please check the provided blob name." ) content = blob.download_as_string() if blob and blob.content_encoding: content = content.decode(blob.content_encoding) # check if the returned content is a json try: try: result = json.loads(content) except TypeError: result = json.loads(content.decode("UTF-8")) except json.JSONDecodeError: print( "The loaded content is not a valid JSON. Please check the source bucket and blob." ) raise if dest_file_name: with open(dest_file_name, "w") as dest: dest.write(content) return "The message was written to {} successfully.".format( dest_file_name) return JSON(result)
def display_json(doc: Dict[str, Any], root: Optional[str] = "root") -> IPython.core.display.JSON: """ Create a JSON display object given raw JSON data. Parameters ---------- doc : JSON dict or list Raw JSON data to display. root : str, optional The name of the root element of the JSON tree (default 'root'). Returns ------- IPython display of JSON data : IPython.core.display.JSON An IPython JSON display representing the data. Example ------- >>> from aws.utils.notebooks import json as json_utils >>> json_utils.display_json(doc=my_schemas ,root="database") """ return JSON(doc)
def wstl(self, line, cell): """Cell magic to evaluate whistle mapping language from iPython kernel.""" args = magic_arguments.parse_argstring(self.wstl, line) # TODO (b/157468786): migrate to secure channel. with grpc.insecure_channel(self.grpc_target) as channel: stub = wstlservice_pb2_grpc.WhistleServiceStub(channel) (incremental_session, err) = _get_or_create_session(stub, self.shell) if err: return err (transform, err) = _get_incremental_transform(stub, self.shell, incremental_session.session_id, args, cell) if err: return err result = _response_to_json(transform) if args.output: self.shell.push({args.output: result}) return JSON(result)
# Render dicts as json in jupyter notebooks if get_ipython().__class__.__name__ == 'ZMQInteractiveShell': from IPython.display import JSON from json import JSONEncoder, loads class MyEncoder(JSONEncoder): def default(self, o): try: return o.as_dict() except: try: return o.__dict__ except: return str(o) show_json = lambda x: display(JSON(loads(MyEncoder().encode(x))))
def _ipython_display_(self): fields_dict = { field.name: str(getattr(self, field.name)) for field in fields(self) } display(JSON(fields_dict))
import numpy as np import matplotlib.pyplot as plt from plotly import offline as py py.init_notebook_mode() t = np.linspace(0, 20, 500) plt.plot(t, np.sin(t)) py.iplot_mpl(plt.gcf()) # %% from IPython.display import JSON data = {"foo": {"bar": "baz"}, "a": 1} JSON(data) # %% import sympy as sp sp.init_printing(use_latex="mathjax") x, y, z = sp.symbols("x y z") f = sp.sin(x * y) + sp.cos(y * z) sp.integrate(f, x) # %% from IPython.display import Math Math( r"i\hbar \frac{dA}{dt}~=~[A(t),H(t)]+i\hbar \frac{\partial A}{\partial t}."
entry_value = "Bytes: {}".format(str(vbytes)) if vbytes < 100000: pass elif vbytes < Mb: entry_value += " ({} kb)".format(vbytes / kb) else: entry_value += " ({} Mb)".format(vbytes / Mb) except: pass elif isscalar(val): entry_value = str(val) manifest.append({ 'name': name, 'size': entry_size, 'type': entry_type, 'value': entry_value, }) self.report({'variables': manifest}) get_ipython()._hydrogen_python = HydrogenPythonPlugin() return {'success': True} try: result = install_kernel_plugin() display(JSON({'hydrogen_python': result})) except: display(JSON({'hydrogen_python': {'success': False}}))
def dict2json(d): return JSON(d)
def _ipython_display_(self): from IPython.display import display, JSON display(JSON(to_dict_basic_types(self._map)))
def _ipython_display_(self, **kwargs): from IPython.display import JSON, display display(JSON(self.dict()))
from IPython.display import display, JSON display(JSON({'hydrogen_python': "pass"}))
def test_fhir_validate_magic_ipython(self, mock_stub, mock_channel): class FakeChannel: def __init__(self, channel): self.channel = channel def __enter__(self): return self.channel def __exit__(self, exc_type, exc_val, exc_tb): self.channel._close() return False class FakeService: def __init__(self, res): self.resp = res def FhirValidate(self, req): del req return self.resp mock_channel.return_value = FakeChannel(self._channel) ip = self.shell.get_ipython() failure = ip.magics_manager.register(wstl.WSTLMagics) self.assertIsNone(failure) st1 = "{'id':'example','resourceType':'Device','udi':{'carrierHRF':'test'}}" st2 = "{'id':'example','resourceType':'3','udi':{'carrierHRF':'test'}}" stList = [st1, st1] ip.push("st1") ip.push("st2") ip.push("stList") lines = [ "--version=stu3 --input=py://st1", "--version=stu3 --input=py://st2", "--version=stu3 --input=py://stList", "--version=stu3 --input=pylist://stList" ] results = [] resps = [ wstlservice_pb2.ValidationResponse(status=[ status_pb2.Status(code=code_pb2.OK, message="Validation Success") ]), wstlservice_pb2.ValidationResponse(status=[ status_pb2.Status( code=code_pb2.INVALID_ARGUMENT, message="invalid FHIR resource") ]), wstlservice_pb2.ValidationResponse(status=[ status_pb2.Status( code=code_pb2.INVALID_ARGUMENT, message="invalid FHIR resource") ]), wstlservice_pb2.ValidationResponse(status=[ status_pb2.Status(code=code_pb2.OK, message="Validation Success") ]), ] reqs = [ wstlservice_pb2.ValidationRequest( fhir_version=wstlservice_pb2.ValidationRequest.FhirVersion.STU3, input=[ wstlservice_pb2.Location( inline_json="{'id':'example','resourceType':" + "'Device','udi':{'carrierHRF':'test'}}") ]), wstlservice_pb2.ValidationRequest( fhir_version=wstlservice_pb2.ValidationRequest.FhirVersion.STU3, input=[ wstlservice_pb2.Location( inline_json="{'id':'example','resourceType':" + "'3','udi':{'carrierHRF':'test'}}") ]), wstlservice_pb2.ValidationRequest( fhir_version=wstlservice_pb2.ValidationRequest.FhirVersion.STU3, input=[ wstlservice_pb2.Location( inline_json="[\"{'id':'example','resourceType':" + "'Device','udi':{'carrierHRF':'test'}}\", " + "\"{'id':'example','resourceType':" + "'Device','udi':{'carrierHRF':'test'}}\"]") ]), wstlservice_pb2.ValidationRequest( fhir_version=wstlservice_pb2.ValidationRequest.FhirVersion.STU3, input=[ wstlservice_pb2.Location( inline_json="{'id':'example','resourceType':" + "'Device','udi':{'carrierHRF':'test'}}"), wstlservice_pb2.Location( inline_json="{'id':'example','resourceType':" + "'Device','udi':{'carrierHRF':'test'}}"), ]), ] for i in range(len(lines)): mock_service = mock.create_autospec(FakeService) mock_service.FhirValidate.return_value = resps[i] mock_stub.return_value = mock_service result = ip.run_line_magic("fhir_validate", lines[i]) results.append(result) mock_service.FhirValidate.assert_called_once_with(reqs[i]) wants = [ "{'status': [{'message': 'Validation Success'}]}", "{'status': [{'code': 3, 'message': 'invalid FHIR resource'}]}", "{'status': [{'code': 3, 'message': 'invalid FHIR resource'}]}", "{'status': [{'message': 'Validation Success'}]}", ] for j in range(len(wants)): result = results[j] want = JSON(wants[j]) self.assertEqual( result.data, want.data, msg="JSON.data mismatch on input {}".format(lines[j])) self.assertEqual( result.url, want.url, msg="JSON.url mismatch on input {}".format(lines[j])) self.assertEqual( result.filename, want.filename, msg="JSON.filename mismatch on input {}".format(lines[j])) # Delete created variables to suppress the unused-variable linter warning. del st1 del st2 del stList
def as_json(obj): return JSON(json.dumps(obj.__dict__), expanded=True)
def report(self, val): display(JSON({'hydrogen_python': val}))
def display_dict2json(d): display(JSON(d))
})) return df_summary reverse_dict = lambda original_dict: { value: key for key, value in original_dict.items() } capfirst = lambda s: s[:1].upper() + s[1:] keep_index = lambda df, func, *args, **kwargs: pd.DataFrame( func(df, *args, **kwargs), index=df.index) view_dict_head = lambda d, n=5: JSON(pd.Series(d).head(n).to_dict()) # Slack msg_2_data = lambda record_msg: f'{"{"}"text":"{record_msg}"{"}"}' def send_slack_msg( record_msg, slack_channel_url="", ): headers = {"Content-type": "application/json"} data = msg_2_data(record_msg) try: requests.post(slack_channel_url, headers=headers, data=data) except: