# packages

pkgId: 6a0ac278fe2d191cf0bc8273878dcee28b3b36271125fb78a63db5508df23b1c
name: python-dash-pydantic-form
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Create Dash forms from pydantic objects
url: https://pydf-docs.onrender.com
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-pydantic-form-0.9.1-1.src.rpm
checksum_type: sha256
description:
  This package allows users to quickly create forms with Plotly Dash based on pydantic models.

  See the full docs at [dash-pydantic-form docs](https://pydf-docs.onrender.com).

  Check out a full self-standing example app in [usage.py](usage.py).



  Install with pip

  ```sh
  pip install dash-pydantic-form
  ```

  Create a pydantic model you would like to display a form for.

  *Note: This package uses pydantic 2.*

  ```py
  from datetime import date
  from typing import Literal
  from pydantic import BaseModel, Field

  class Employee(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      office: Literal["au", "uk", "us", "fr"] = Field(title="Office")
      joined: date = Field(title="Employment date")
  ```

  Then you can get an auto-generated form with `ModelForm`, leveraging [dash-mantine-components](https://dash-mantine-components.com) (version 0.14) for form inputs.

  ```py
  from dash_pydantic_form import ModelForm


  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
  )
  ```

  ![Simple form](images/simple-form.png)

  You can also render a pre-filled form by passing an instance of the data model rather than the class

  ```py

  bob = Employee(first_name="Bob", last_name="K", office="au", joined="2020-05-20")

  form = ModelForm(
      bob,
      aio_id="employees",
      form_id="bob",
  )
  ```

  You can then retrieve the contents of the whole form at once in a callback as follows

  ```py
  from dash import Input, Output, callback

  @callback(
      Output("some-output-id", "some-output-attribute"),
      Input(ModelForm.ids.main("employees", "new_employee"), "data"),
  )
  def use_form_data(form_data: dict):
      try:
          print(Employee(**form_data))
      except ValidationError as exc:
          print("Could not validate form data:")
          print(exc.errors())
      return # ...
  ```



  The `ModelForm` will automaticlly pick which input type to use based on the type annotation for the model field. However, you can customise how each field input is rendered, and or pass additional props to the DMC component.

  ```py
  from dash_pydantic_form import ModelfForm, fields

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          
          
          "office": fields.RadioItems(description="Wich country office?"),
          
          "joined": {"maxDate": "2024-01-01"},
      },
  )
  ```

  You can also customise inputs by adding arguments to the fields' json_schema_extra if you don't mind mixing data and presentation layers.

  ```py
  class Employee(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      office: Literal["au", "uk", "us", "fr"] = Field(
          title="Office",
          description="Wich country office?",
          
          json_schema_extra={"repr_type": "RadioItems"},
      )
      joined: date = Field(
          title="Employment date",
          
          json_schema_extra={"repr_kwargs": {"maxDate": "2024-01-01"}},
      )

  form = ModelForm(Employee, aio_id="employees", form_id="new_employee")
  ```

  Note: You can currently skip the `json_schema_extra=...` and just pass `repr_type=..., repr_kwargs=...` in the field. However, the `**extras` keyword arguments are deprecated on pydantic's `Field` so using `json_schema_extra` is more future-proof.



  Based on DMC:
  * Checkbox
  * Checklist
  * Color
  * Date
  * Json
  * Month
  * MultiSelect
  * Number
  * Password
  * RadioItems
  * Range
  * Rating
  * SegmentedControl
  * Select
  * Slider
  * Switch
  * Tags
  * Textarea
  * Text
  * Time
  * Year

  Custom:
  * Dict
  * Table
  * List
  * Markdown
  * Model
  * Path
  * Quantity
  * TransferList



  There are 2 main avenues to create form sections:



  ```py
  class HRData(BaseModel):
      office: Literal["au", "uk", "us", "fr"] = Field(title="Office")
      joined: date = Field(title="Employment date")

  class EmployeeNested(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      hr_data: HRData = Field(title="HR data")
  ```
  ModelForm will then recognise HRData as a pydantic model and use the `fields.Model` to render it, de facto creating a section.

  ![Nested model](images/nested-model.png)



  ```py
  from dash_pydantic_form import FormSection, ModelForm, Sections

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      sections=Sections(
          sections=[
              FormSection(name="General", fields=["first_name", "last_name"], default_open=True),
              FormSection(name="HR data", fields=["office", "joined"], default_open=False),
          ],
          
          render="tabs",
      ),
  )
  ```

  ![Form sections](images/form-sections.png)



  Dash pydantic form also handles lists of nested models with the possibility to add/remove items from the list and edit each one.

  Let's say we now want to record the employee's pets



  This creates a list of sub-forms each of which can take similar arguments as a ModelForm (fields_repr, sections).

  ```py
  class Pet(BaseModel):
      name: str = Field(title="Name")
      species: Literal["cat", "dog"] = Field(title="Species")
      age: int = Field(title="Age")

  class Employee(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      pets: list[Pet] = Field(title="Pets", default_factory=list)

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "pets": fields.List(
              fields_repr={
                  "species": {"options_labels": {"cat": "Cat", "dog": "Dog"}}
              },
              
              render_type="accordion",
          )
      },
  )
  ```

  ![List](images/model-list.png)



  You can also represent the list of sub-models as an ag-grid table with `fields.Table`.

  ```py
  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "pets": fields.Table(
              fields_repr={
                  "species": {"options_labels": {"cat": "Cat", "dog": "Dog"}}
              },
          )
      },
  )
  ```

  ![Table](images/editable-table.png)




  You can make field visibility depend on the value of other fields in the form. To do so, simply pass a `visible` argument to the field.

  ```py
  class Employee(BaseModel):
      first_name: str
      last_name: str
      only_bob: str | None = Field(
          title="Only for Bobs",
          description="What's your favourite thing about being a Bob?",
          default=None,
      )

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "only_bob": fields.Textarea(
              visible=("first_name", "==", "Bob"),
          )
      },
  )
  ```

  ![Conditionally visible field](images/conditionnally-visible-field.gif)

  `visible` accepts a boolean, a 3-tuple or list of 3-tuples with format: (field, operator, value). The available operators are:
  * "=="
  * "!="
  * "in"
  * "not in"
  * "array_contains"
  * "array_contains_any"

  NOTE: The field in the 3-tuples is a ":" separated path relative to the current field's level of nesting. If you need to reference a field from a parent or the root use the special values `_parent_` or `_root_`.

  E.g., `visible=("_root_:first_name", "==", "Bob")`



  Dash pydantic form supports Pydantic [discriminated unions with str discriminator](https://docs.pydantic.dev/latest/concepts/unions/#discriminated-unions-with-str-discriminators)

  ```py
  class HomeOffice(BaseModel):
      """Home office model."""

      type: Literal["home_office"]
      has_workstation: bool = Field(title="Has workstation", description="Does the employee have a suitable workstation")


  class WorkOffice(BaseModel):
      """Work office model."""

      type: Literal["work_office"]
      commute_time: int = Field(title="Commute time", description="Commute time in minutes", ge=0)

  class Employee(BaseModel):
      name: str = Field(title="Name")
      work_location: HomeOffice | WorkOffice | None = Field("Work location", default=None, discriminator="type")

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "work_location": {
              "fields_repr": {
                  "type": fields.RadioItems(
                      options_labels={"home_office": "Home", "work_office": "Work"}
                  )
              },
          },
      }
  )
  ```

  ![Discriminated union](images/discriminated-union.gif)



  *To be written*

rpm_license:
  The MIT License (MIT)  Copyright (c) 2023 Plotly, Inc  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: ace870fe57488e609ecd55dd73f00e62fa37c15d770ed01f6960e9c51a64ed66
name: python-dash-pydantic-form
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Create Dash forms from pydantic objects
url: https://pydf-docs.onrender.com
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-pydantic-form-0.9.2-1.src.rpm
checksum_type: sha256
description:
  This package allows users to quickly create forms with Plotly Dash based on pydantic models.

  See the full docs at [dash-pydantic-form docs](https://pydf-docs.onrender.com).

  Check out a full self-standing example app in [usage.py](usage.py).



  Install with pip

  ```sh
  pip install dash-pydantic-form
  ```

  Create a pydantic model you would like to display a form for.

  *Note: This package uses pydantic 2.*

  ```py
  from datetime import date
  from typing import Literal
  from pydantic import BaseModel, Field

  class Employee(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      office: Literal["au", "uk", "us", "fr"] = Field(title="Office")
      joined: date = Field(title="Employment date")
  ```

  Then you can get an auto-generated form with `ModelForm`, leveraging [dash-mantine-components](https://dash-mantine-components.com) (version 0.14) for form inputs.

  ```py
  from dash_pydantic_form import ModelForm


  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
  )
  ```

  ![Simple form](images/simple-form.png)

  You can also render a pre-filled form by passing an instance of the data model rather than the class

  ```py

  bob = Employee(first_name="Bob", last_name="K", office="au", joined="2020-05-20")

  form = ModelForm(
      bob,
      aio_id="employees",
      form_id="bob",
  )
  ```

  You can then retrieve the contents of the whole form at once in a callback as follows

  ```py
  from dash import Input, Output, callback

  @callback(
      Output("some-output-id", "some-output-attribute"),
      Input(ModelForm.ids.main("employees", "new_employee"), "data"),
  )
  def use_form_data(form_data: dict):
      try:
          print(Employee(**form_data))
      except ValidationError as exc:
          print("Could not validate form data:")
          print(exc.errors())
      return # ...
  ```



  The `ModelForm` will automaticlly pick which input type to use based on the type annotation for the model field. However, you can customise how each field input is rendered, and or pass additional props to the DMC component.

  ```py
  from dash_pydantic_form import ModelfForm, fields

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          
          
          "office": fields.RadioItems(description="Wich country office?"),
          
          "joined": {"maxDate": "2024-01-01"},
      },
  )
  ```

  You can also customise inputs by adding arguments to the fields' json_schema_extra if you don't mind mixing data and presentation layers.

  ```py
  class Employee(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      office: Literal["au", "uk", "us", "fr"] = Field(
          title="Office",
          description="Wich country office?",
          
          json_schema_extra={"repr_type": "RadioItems"},
      )
      joined: date = Field(
          title="Employment date",
          
          json_schema_extra={"repr_kwargs": {"maxDate": "2024-01-01"}},
      )

  form = ModelForm(Employee, aio_id="employees", form_id="new_employee")
  ```

  Note: You can currently skip the `json_schema_extra=...` and just pass `repr_type=..., repr_kwargs=...` in the field. However, the `**extras` keyword arguments are deprecated on pydantic's `Field` so using `json_schema_extra` is more future-proof.



  Based on DMC:
  * Checkbox
  * Checklist
  * Color
  * Date
  * Json
  * Month
  * MultiSelect
  * Number
  * Password
  * RadioItems
  * Range
  * Rating
  * SegmentedControl
  * Select
  * Slider
  * Switch
  * Tags
  * Textarea
  * Text
  * Time
  * Year

  Custom:
  * Dict
  * Table
  * List
  * Markdown
  * Model
  * Path
  * Quantity
  * TransferList



  There are 2 main avenues to create form sections:



  ```py
  class HRData(BaseModel):
      office: Literal["au", "uk", "us", "fr"] = Field(title="Office")
      joined: date = Field(title="Employment date")

  class EmployeeNested(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      hr_data: HRData = Field(title="HR data")
  ```
  ModelForm will then recognise HRData as a pydantic model and use the `fields.Model` to render it, de facto creating a section.

  ![Nested model](images/nested-model.png)



  ```py
  from dash_pydantic_form import FormSection, ModelForm, Sections

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      sections=Sections(
          sections=[
              FormSection(name="General", fields=["first_name", "last_name"], default_open=True),
              FormSection(name="HR data", fields=["office", "joined"], default_open=False),
          ],
          
          render="tabs",
      ),
  )
  ```

  ![Form sections](images/form-sections.png)



  Dash pydantic form also handles lists of nested models with the possibility to add/remove items from the list and edit each one.

  Let's say we now want to record the employee's pets



  This creates a list of sub-forms each of which can take similar arguments as a ModelForm (fields_repr, sections).

  ```py
  class Pet(BaseModel):
      name: str = Field(title="Name")
      species: Literal["cat", "dog"] = Field(title="Species")
      age: int = Field(title="Age")

  class Employee(BaseModel):
      first_name: str = Field(title="First name")
      last_name: str = Field(title="Last name")
      pets: list[Pet] = Field(title="Pets", default_factory=list)

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "pets": fields.List(
              fields_repr={
                  "species": {"options_labels": {"cat": "Cat", "dog": "Dog"}}
              },
              
              render_type="accordion",
          )
      },
  )
  ```

  ![List](images/model-list.png)



  You can also represent the list of sub-models as an ag-grid table with `fields.Table`.

  ```py
  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "pets": fields.Table(
              fields_repr={
                  "species": {"options_labels": {"cat": "Cat", "dog": "Dog"}}
              },
          )
      },
  )
  ```

  ![Table](images/editable-table.png)




  You can make field visibility depend on the value of other fields in the form. To do so, simply pass a `visible` argument to the field.

  ```py
  class Employee(BaseModel):
      first_name: str
      last_name: str
      only_bob: str | None = Field(
          title="Only for Bobs",
          description="What's your favourite thing about being a Bob?",
          default=None,
      )

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "only_bob": fields.Textarea(
              visible=("first_name", "==", "Bob"),
          )
      },
  )
  ```

  ![Conditionally visible field](images/conditionnally-visible-field.gif)

  `visible` accepts a boolean, a 3-tuple or list of 3-tuples with format: (field, operator, value). The available operators are:
  * "=="
  * "!="
  * "in"
  * "not in"
  * "array_contains"
  * "array_contains_any"

  NOTE: The field in the 3-tuples is a ":" separated path relative to the current field's level of nesting. If you need to reference a field from a parent or the root use the special values `_parent_` or `_root_`.

  E.g., `visible=("_root_:first_name", "==", "Bob")`



  Dash pydantic form supports Pydantic [discriminated unions with str discriminator](https://docs.pydantic.dev/latest/concepts/unions/#discriminated-unions-with-str-discriminators)

  ```py
  class HomeOffice(BaseModel):
      """Home office model."""

      type: Literal["home_office"]
      has_workstation: bool = Field(title="Has workstation", description="Does the employee have a suitable workstation")


  class WorkOffice(BaseModel):
      """Work office model."""

      type: Literal["work_office"]
      commute_time: int = Field(title="Commute time", description="Commute time in minutes", ge=0)

  class Employee(BaseModel):
      name: str = Field(title="Name")
      work_location: HomeOffice | WorkOffice | None = Field("Work location", default=None, discriminator="type")

  form = ModelForm(
      Employee,
      aio_id="employees",
      form_id="new_employee",
      fields_repr={
          "work_location": {
              "fields_repr": {
                  "type": fields.RadioItems(
                      options_labels={"home_office": "Home", "work_office": "Work"}
                  )
              },
          },
      }
  )
  ```

  ![Discriminated union](images/discriminated-union.gif)



  *To be written*

rpm_license:
  The MIT License (MIT)  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 44a8a36ea38e4a35f7e12b37f57f6e48ffd5c2bdcd2212eb0918c009d74df080
name: python-dash-snap-grid
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A draggable and resizable grid layout with responsive breakpoints, for Dash
url: https://pypi.org/project/dash-snap-grid/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-snap-grid-0.2.0-1.src.rpm
checksum_type: sha256
description:
  A draggable and resizable grid layout with responsive breakpoints, for Dash.

  (A dash port of [react-grid-layout](https://github.com/react-grid-layout/react-grid-layout)
  with some additional features specific to Dash)

  ![dash-grid-layout](./demo.gif)




  ```bash
  pip install dash-snap-grid
  ```



  You must set the env variable `REACT_VERSION=18.2.0` before starting up the app.

  ```python
  import dash
  from dash import html
  from dash_snap_grid import Grid

  app = dash.Dash(__name__)

  app.layout = html.Div(
      [
          Grid(
              id="grid",
              cols=12,
              rowHeight=100,
              layout=[
                  
                  {"i": "1", "x": 0, "y": 0, "w": 1, "h": 2},
                  {"i": "2", "x": 1, "y": 0, "w": 3, "h": 2},
                  {"i": "3", "x": 4, "y": 0, "w": 1, "h": 2},
              ],
              children=[
                  html.Div(
                      "1", id="1", style={"background": "lightblue", "height": "100%"}
                  ),
                  html.Div(
                      "2", id="2", style={"background": "lightgreen", "height": "100%"}
                  ),
                  html.Div(
                      "3", id="3", style={"background": "lightcoral", "height": "100%"}
                  ),
              ],
          ),
      ]
  )

  if __name__ == "__main__":
      app.run_server(debug=True)

  ```





  The main component that wraps the children and handles the layout.



  - `id` (str): The id of the component.
  - `width` (int): The initial width of the grid.
  - `autoSize` (bool): If true, the grid will automatically resize to fit the children. (default: True)
  - `cols` (int): The number of columns in the grid. (default: 12)
  - `draggableCancel` (str): A css selector for elements that should not trigger drag.
    Use this if you have input elements or buttons inside the grid.
  - `draggableHandle` (str): A css selector for elements that should be used as the drag handle.
  - `compactType` (str | None): The type of compacting to use when moving elements around.
    Options: None, `vertical`, `horizontal`. (default: None)
  - `layout` (List[Dict[str, Any]]): The initial layout of the grid.
    Each item should have the following keys:
    - `i` (str): The id of the child.
    - `x` (int): The x position of the child.
    - `y` (int): The y position of the child.
    - `w` (int): The width of the child. (count of columns)
    - `h` (int): The height of the child. (count of rows)
    The following keys are optional:
    - `minW` (int): The minimum width of the child. (default: 0)
    - `maxW` (int): The maximum width of the child. (default: Infinity)
    - `minH` (int): The minimum height of the child. (default: 0)
    - `maxH` (int): The maximum height of the child. (default: Infinity)
    - `static` (bool): If true, the child cannot be moved or resized. (default: False)
    - `isDraggable` (bool): If false, the child cannot be dragged. (default: True)
    - `isResizable` (bool): If false, the child cannot be resized. (default: True)
    - `isBounded` (bool): If true, the child will be bounded by the grid. (default: False)
  - `persistLayout` (bool): If true, any changes to the layout will be stored in browser storage.
    Reloading the page will restore the last layout update that the user did.
  - `margin` (List[int]): The margin between the children. (default: [10, 10])
  - `containerPadding` (List[int]): The padding of the container. (default: [10, 10])
  - `rowHeight` (int): The height of a row in pixels. (default: 150)
  - `isDraggable` (bool): If true, the children can be dragged. (default: True)
  - `isResizable` (bool): If true, the children can be resized. (default: True)
  - `isBounded` (bool): If true, the children will be bounded by the grid. (default: False)
  - `useCSSTransforms` (bool): If true, the children will be moved using css transforms. (default: True)
  - `transformScale` (float): The scale of the transform. (default: 1)
  - `allowOverlap` (bool): If true, the children can overlap. (default: False)
  - `preventCollision` (bool): If true, the children will not collide with each other. (default: False)
  - `isDroppable` (bool): If true, the children can be dropped. (default: False).
    Once an item is dropped, the `droppedItem` prop will be updated with the layout details
    of the dropped item, which contains the the layout details of the dropped item.
    the `i` key will be set to the id of the dropped item.
  - `resizeHandles` (List[str]): The handles that can be used to resize the children.
    Options: `['s', 'e', 'n', 'w', 'se', 'ne', 'sw', 'nw']`. (default: ['se'])
  - `children` (List[html.Div]): The children of the grid. Make sure the id of the children
    matches the `i` key of the layout items.



  A responsive version of the grid that changes the layout based on the screen size.



  - `id` (str): The id of the component.
  - `width` (int): The initial width of the grid.
  - `autoSize` (bool): If true, the grid will automatically resize to fit the children. (default: True)
  - `breakpoints` (Dict[str, int]): The breakpoints for the grid. The keys should be the screen sizes
    and the values should be the number of columns in the grid for that screen size.
    default: `{'lg': 1200, 'md': 996, 'sm': 768, 'xs': 400, 'xxs': 0}`
  - `cols` (dict[str, int]): Number of columns per screen size. The keys should be the screen sizes
    and the values should be the number of columns in the grid for that screen size.
    default: `{'lg': 12, 'md': 10, 'sm': 6, 'xs': 4, 'xxs': 2}`
  - `draggableCancel` (str): A css selector for elements that should not trigger drag.
    Use this if you have input elements or buttons inside the grid.
  - `draggableHandle` (str): A css selector for elements that should be used as the drag handle.
  - `compactType` (str | None): The type of compacting to use when moving elements around.
    Options: None, `vertical`, `horizontal`. (default: None)
  - `layout` (List[Dict[str, Any]]): The current layout (Read only)
    Each item should have the following keys:
    - `i` (str): The id of the child.
    - `x` (int): The x position of the child.
    - `y` (int): The y position of the child.
    - `w` (int): The width of the child. (count of columns)
    - `h` (int): The height of the child. (count of rows)
    The following keys are optional:
    - `minW` (int): The minimum width of the child. (default: 0)
    - `maxW` (int): The maximum width of the child. (default: Infinity)
    - `minH` (int): The minimum height of the child. (default: 0)
    - `maxH` (int): The maximum height of the child. (default: Infinity)
    - `static` (bool): If true, the child cannot be moved or resized. (default: False)
    - `isDraggable` (bool): If false, the child cannot be dragged. (default: True)
    - `isResizable` (bool): If false, the child cannot be resized. (default: True)
    - `isBounded` (bool): If true, the child will be bounded by the grid. (default: False)
  - `layouts` (Dict[str, List[Dict[str, Any]]]): The initial layout of the grid for each screen size.
    This is dictionary of layouts, where the keys are the screen sizes and the values are the layouts.
    If you want to set the layout for a given screen size, this prop should be set. `layout` prop is only
    to read the current layout.
    for example: `{'lg': [...], 'md': [...], 'sm': [...], 'xs': [...], 'xxs': [...]}`.
  - `persistLayout` (bool): If true, any changes to the layout will be stored in browser storage.
    The layout change made at each breakpoint will be saved separately. So layout presistance will happen
    at each breakpoint.
  - `margin` (List[int] | dict[str, int]): The margin between the children. (default: [10, 10])
    You can also specify the margin for each screen size by passing a dictionary.
    for example: `{'lg': [10, 10], 'md': [5, 5], 'sm': [2, 2], 'xs': [1, 1], 'xxs': [0, 0]}`
  - `containerPadding` (List[int] | dict[str, int]): The padding of the container. (default: [10, 10])
    Similar to the margin, you can also specify the padding for each screen size by passing a dictionary.
  - `rowHeight` (int): The height of a row in pixels. (default: 150)
  - `isDraggable` (bool): If true, the children can be dragged. (default: True)
  - `isResizable` (bool): If true, the children can be resized. (default: True)
  - `isBounded` (bool): If true, the children will be bounded by the grid. (default: False)
  - `useCSSTransforms` (bool): If true, the children will be moved using css transforms. (default: True)
  - `transformScale` (float): The scale of the transform. (default: 1)
  - `allowOverlap` (bool): If true, the children can overlap. (default: False)
  - `preventCollision` (bool): If true, the children will not collide with each other. (default: False)
  - `isDroppable` (bool): If true, the children can be dropped. (default: False).
    Once an item is dropped, the `droppedItem` prop will be updated with the layout details
    of the dropped item, which contains the the layout details of the dropped item.
    the `i` key will be set to the id of the dropped item.
  - `resizeHandles` (List[str]): The handles that can be used to resize the children.
    Options: `['s', 'e', 'n', 'w', 'se', 'ne', 'sw', 'nw']`. (default: ['se'])
  - `children` (List[html.Div]): The children of the grid. Make sure the id of the children
    matches the `i` key of the layout items.



  A draggable div that can be used as a an item that can be dragged and dropped in the grid.



  - `id` (str): The id of the component.
  - `children` (html.Div): The children of the div.
  - `style` (dict): The style of the div.


pkgId: 44c0760fb396c5badd4af71c066639c8d9c40ce52579ef88436db8f7ff773e32
name: python-dash-svg
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: SVG support library for Plotly/Dash
url: https://pypi.org/project/dash-svg/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-svg-0.0.12-1.src.rpm
checksum_type: sha256
description:
  ![](https://raw.githubusercontent.com/stevej2608/dash-svg/master/docs/img/dash-minimal.png)

  Scalable Vector Graphics (SVG) library for [Plotly/Dash](https://dash.plotly.com/)

  Dash clone of the ubiquitous *create-react-app* default project,
  ```
  import dash
  from dash import html
  from dash_svg import Svg, G, Path, Circle


  app = dash.Dash(__name__)

  app.layout = html.Div([
      html.Header([
          Svg([
              G([
                  Path(d='...'),
                  Circle(cx="420.9", cy="296.5", r='45.7'),
                  Path(d='M520.5 78.1z')
              ], fill='#61DAFB')
          ], viewBox='0 0 841.9 595.3', className="App-logo", alt="logo"),
          html.P(["Edit ", html.Code("usage.py"), " and save to reload."]),
          html.A("Learn Dash", className="App-link", href="https://dash.plotly.com/",  target="_blank", rel="noopener noreferrer")
      ], className="App-header")
  ], className="App")


  if __name__ == '__main__':
      app.run_server(debug=True)
  ```



  You can install *dash-svg* with `pip`:

  ```
  pip install dash-svg
  ```



  Head over to the [*README*][docs-homepage] for more details.



  The source code for *dash-svg* is available
  [on GitHub][dash-svg-repo]. If you find a bug or something is unclear, we encourage
  you to raise an issue. We also welcome contributions, to contribute, fork the
  repository and open a [pull request][dash-svg-pulls].


  [dash-homepage]: https://dash.plot.ly/
  [dash-svg-repo]: https://github.com/stevej2608/dash-svg
  [docs-homepage]: https://github.com/stevej2608/dash-svg/blob/master/README.md
  [dash-svg-pulls]: https://github.com/stevej2608/dash-svg/pulls


pkgId: f7d0ea7cae1952ed39459b0a0210cbb153bf87cbff6f46ab7c9bcfe22d72121f
name: python-dash-table
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: Dash table
url: https://pypi.org/project/dash-table/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-table-5.0.0-1.src.rpm
checksum_type: sha256
description:
  An interactive `DataTable` for [Dash](https://dash.plotly.com/).

  ```
  pip install dash-table
  ```
  ```python
  import dash
  import dash_table
  import pandas as pd
  df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/solar.csv')
  app = dash.Dash(__name__)
  app.layout = dash_table.DataTable(
      id='table',
      columns=[{"name": i, "id": i} for i in df.columns],
      data=df.to_dict('records'),
  )
  if __name__ == '__main__':
      app.run_server(debug=True)
  ```
  ![Interactive Dash DataTable](https://user-images.githubusercontent.com/1280389/47935912-67187080-deb2-11e8-8936-34b0c99b518f.png)

  Dash DataTable is an interactive table component designed for viewing, editing, and exploring large datasets.
  DataTable is rendered with standard, semantic HTML `<table/>` markup, which makes it accessible, responsive, and easy to style.
  This component was written from scratch in React.js and Typescript specifically for the Dash community. Its API was designed to be ergonomic and its behavior is completely customizable through its properties.
  DataTable was designed with a featureset that allows that Dash users to create complex, spreadsheet driven applications with no compromises. We're excited to continue to work with users and companies that [invest in DataTable's future](https://plotly.com/products/consulting-and-oem/).
  Please subscribe to [dash-table#207](https://github.com/plotly/dash-table/issues/207) and the [CHANGELOG.md](https://github.com/plotly/dash-table/blob/master/CHANGELOG.md) to stay up-to-date with any breaking changes. Note: DataTable is currently supported in Chrome, Firefox, Safari, Edge (version 15+), and Internet Explorer 11.
  Share your DataTable Dash apps on the [community forum](https://community.plotly.com/t/show-and-tell-community-thread/7554)!

  See [CONTRIBUTING.md](https://github.com/plotly/dash-table/blob/master/CONTRIBUTING.md)


pkgId: 216f3426ed0d716d6eb52777575c6b3b2b16c71e1d0275ea181592c7c9a176ca
name: python-dash-tabulator
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Dash Plotly component providing Tabulator tables
url: https://github.com/preftech/dash-tabulator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-tabulator-0.4.2-1.src.rpm
checksum_type: sha256
description:
  - [Dash Tabulator](#dash-tabulator)
    - [Features](#features)
    - [Installation](#installation)
    - [Usage](#usage)
    - [Themes](#themes)
  - [Advanced Usage](#advanced-usage)
    - [Multiple Row Selection](#multiple-row-selection)
    - [Javascript](#javascript)
    - [Javascript Cell Formatting Example](#javascript-cell-formatting-example)
    - [Javascript column resizing capture](#javascript-column-resizing-capture)
    - [Links](#links)



  Dash tabulator is a Dash / Plotly component providing [Tabulator](http://tabulator.info/) capabilities.
  This is not a fully comprehensive implementation of Tabulator just the basics necessary to get the application working.
  Under the covers this uses [react-tabulator](https://github.com/ngduc/react-tabulator)

  ![Dash Tabulator](docs/dash_tabulator.gif)

  This is built on the shoulders of the Dash Plotly team, the Tabulator team, and the React Tabulator team.
  This readme is probably longer than the code, due to the work of those individuals!



  * [Tabulator Column settings ](http://tabulator.info/docs/4.1/columns)
    * Sorting / Filtering etc.
  * Data loading through [Dash Plotly callbacks](https://dash.plotly.com/basic-callbacks)
  * Row Click Callbacks
  * Data Changed Callbacks (contains the new data table, note warning on this)
  * Cell Edit Callbacks, capture the cell that was just changed, requires setting "editor":"input" etc.. on column header
  * Download button to export as [csv / xlsx / pdf](http://tabulator.info/docs/4.2/download)
    * XLSX & PDF require 3 party js scripts, see above link for details
  * Javascript bindings
    * Contributed by Emil Haldrup Eriksen https://github.com/emilhe
    *  See pull request https://github.com/preftech/dash-tabulator/pull/11




  Installation can be done with pip in your dash project
  ```bash
  pip install dash_tabulator
  pip install dash_extensions
  ```


  Sample usage

  ```python
  import dash_tabulator
  import dash
  from dash.dependencies import Input, Output
  import dash_html_components as html
  import dash_core_components as dcc
  from textwrap import dedent as d
  import json


  external_scripts = ['https://oss.sheetjs.com/sheetjs/xlsx.full.min.js']


  external_stylesheets = ['https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css']


  app = dash.Dash(__name__, external_scripts=external_scripts, external_stylesheets=external_stylesheets)

  styles = {
              'pre': {
                  'border': 'thin lightgrey solid',
                  'overflowX': 'scroll'
              }
          }





  columns = [
                  { "title": "Name", "field": "name", "width": 150, "headerFilter":True, "editor":"input"},
                  { "title": "Age", "field": "age", "hozAlign": "left", "formatter": "progress" },
                  { "title": "Favourite Color", "field": "col", "headerFilter":True },
                  { "title": "Date Of Birth", "field": "dob", "hozAlign": "center" },
                  { "title": "Rating", "field": "rating", "hozAlign": "center", "formatter": "star" },
                  { "title": "Passed?", "field": "passed", "hozAlign": "center", "formatter": "tickCross" }
                ]


  data = [
                  {"id":1, "name":"Oli Bob", "age":"12", "col":"red", "dob":""},
                  {"id":2, "name":"Mary May", "age":"1", "col":"blue", "dob":"14/05/1982"},
                  {"id":3, "name":"Christine Lobowski", "age":"42", "col":"green", "dob":"22/05/1982"},
                  {"id":4, "name":"Brendon Philips", "age":"125", "col":"orange", "dob":"01/08/1980"},
                  {"id":5, "name":"Margret Marmajuke", "age":"16", "col":"yellow", "dob":"31/01/1999"},
                  {"id":6, "name":"Fred Savage", "age":"16", "col":"yellow", "rating":"1", "dob":"31/01/1999"},
                  {"id":6, "name":"Brie Larson", "age":"30", "col":"blue", "rating":"1", "dob":"31/01/1999"},
                ]







  options = { "groupBy": "col", "selectable":1}








  downloadButtonType = {"css": "btn btn-primary", "text":"Export", "type":"xlsx"}






  clearFilterButtonType = {"css": "btn btn-outline-dark", "text":"Clear Filters"}









  app.layout = html.Div([
      dash_tabulator.DashTabulator(
          id='tabulator',
          
          
          options=options,
          downloadButtonType=downloadButtonType,
          clearFilterButtonType=clearFilterButtonType
      ),
      html.Div(id='output'),
      dcc.Interval(
                  id='interval-component-iu',
                  interval=1*10, # in milliseconds
                  n_intervals=0,
                  max_intervals=0
              )

  ])



  @app.callback([ Output('tabulator', 'columns'),
                  Output('tabulator', 'data')],
                  [Input('interval-component-iu', 'n_intervals')])
  def initialize(val):
      return columns, data







  @app.callback(Output('output', 'children'),
      [Input('tabulator', 'rowClicked'),
      Input('tabulator', 'cellEdited'),
      Input('tabulator', 'dataChanged'),
      Input('tabulator', 'dataFiltering'),
      Input('tabulator', 'dataFiltered')])
  def display_output(row, cell, dataChanged, filters, dataFiltered):
      print(row)
      print(cell)
      print(dataChanged)
      print(filters)
      print(dataFiltered)
      return 'You have clicked row {} ; cell {}'.format(row, cell)




  if __name__ == '__main__':
      app.run_server(debug=True)

  ```

  Be aware registering a callback for dataChanged will send the entire table back each time a change occurs
  Make sure you are conscious of the amount of data you are round tripping.

  dataFiltering will return the filters before a match has occurred, usually a partial match
  ```python
  [{'field': 'col', 'type': 'like', 'value': 'yello'}]
  ```

  dataFiltered will return the header filter and the row data e.g.
  ```python
  {
      'filters': [{'field': 'col', 'type': 'like', 'value': 'yellow'}],
      'rows': [
                None,
                None,
                {'id': 5, 'name': 'Margret Marmajuke', 'age': '16', 'col': 'yellow', 'dob': '31/01/1999'},
                {'id': 6, 'name': 'Fred Savage', 'age': '16', 'col': 'yellow', 'rating': '1', 'dob': '31/01/1999'}
                ]
  }
  ```


  React-Tabulator comes with several themes that can be used in Dash-Tabulator
  Dash-Tabulator uses the default theme tabulator.min.css
  The theme can be set in the Dash-Tabulator constructor
  e.g.
  ```python
  app.layout = html.Div([
      dash_tabulator.DashTabulator(
          id='tabulator',
          theme='tabulator_simple',  #optional
          options=options,
          downloadButtonType=downloadButtonType,
          clearFilterButtonType=clearFilterButtonType,
      ),
      ....
  ])
  ```
  The following are the built in react-tabulator themes
  - tabulator or default => react-tabulator/lib/css/tabulator.min.css
  - tabulator_modern => react-tabulator/lib/css/tabulator_modern.min.css
  - tabulator_midnight => react-tabulator/lib/css/tabulator_midnight.min.css
  - tabulator_simple => react-tabulator/lib/css/tabulator_simple.min.css
  - tabulator_site => react-tabulator/lib/css/tabulator_site.min.css
  - bootstrap/tabulator_bootstrap => react-tabulator/lib/css/bootstrap/tabulator_bootstrap.min.css
  - bootstrap/tabulator_bootstrap4 => react-tabulator/lib/css/bootstrap/tabulator_bootstrap4.min.css
  - bulma/tabulator_bulma => react-tabulator/lib/css/bulma/tabulator_bulma.min.css
  - materialize/tabulator_materialize => react-tabulator/lib/css/materialize/tabulator_materialize.min.css
  - semantic-ui/tabulator_semantic-ui => react-tabulator/lib/css/semantic-ui/tabulator_semantic-ui.min.css





  Tabulator supports multiple row selection
  To Enable the table option selectable must be set to the STRING true
  ```python
  options = { "selectable":"true", ....}
  ```

  Once selectable is set
  ```python
  @app.callback(Output('output', 'children'),
      [Input('tabulator', 'rowClicked'),
      Input('tabulator', 'multiRowsClicked')]
  def clickedRows(rowClicked, multiRowsClicked):
    ......
    ......
  ```
  multiRowsClicked will now contain an array of all the rows selected
  e.g.
  ```python
   [
      {'id': 6, 'name': 'Fred Savage', 'age': '16', 'col': 'yellow', 'rating': '1', 'dob': '31/01/1999', 'print': 'foo'},
      {'id': 5, 'name': 'Margret Marmajuke', 'age': '16', 'col': 'yellow', 'dob': '31/01/1999', 'print': 'foo'},
      {'id': 4, 'name': 'Brendon Philips', 'age': '125', 'col': 'orange', 'dob': '01/08/1980', 'print': 'foo'},
      {'id': 3, 'name': 'Christine Lobowski', 'age': '42', 'col': 'green', 'dob': '22/05/1982', 'print': 'foo'}
  ]
  ```

  Select all / deselect all can be accomplished with a header formatter called rowSelection.

  ```python
  columns = [
                  {"formatter":"rowSelection", "titleFormatter":"rowSelection", "hozAlign":"center", "headerSort":"false"},
                  { "title": "Name", "field": "name", "width": 150, "headerFilter":True, "editor":"input"},
  ```
  For more options check out http://tabulator.info/docs/4.8/select



  Tabulator offers a significate amount of callbacks that allow for interactivity with tables to be captured
  and modified http://tabulator.info/docs/4.8/callbacks
  To enable this functionality we can use Dash-Extensions

  Create an assets folder, add a javascript file with your custom functions
  An example is provided in assets/custom_tabulator.js
  Please follow the examples below


  Contributed in https://github.com/preftech/dash-tabulator/pull/11
  Tabulator offers Javascript formatting of cells http://tabulator.info/docs/3.4?#formatting
  This a browser side javascript method attached to a header colum.

  * Create an assets directory
    * See https://dash.plotly.com/external-resources for customization options
  * Add a javascript file with a window.<CustomNameSpace> method (below we call it myNamespace)
    * An example is provided in the assets/custom_tabulator.js file
    * Note the Namespace and the function printIcon
  * Register that method in your python app
    * Using  dash_extensions.javascript.Namespace
  * Add the registered function to your colums formatter


  Python code:
  ```python
  from dash_extensions.javascript import Namespace
  ...
  ns = Namespace("myNamespace", "tabulator")
  ...
  columns = [{"formatter": ns("printIcon")}, ...]
  ```

  Javascript code:
  ```javascript
  window.myNamespace = Object.assign({}, window.myNamespace, {
      tabulator: {
          printIcon: function (cell, formatterParams, onRendered) {
              return "<i class='fa fa-print'></i>";
          }
      }
  });
  ```


  Capturing a column resize, when a user drags a column width
  From tabulators callbacks page http://tabulator.info/docs/4.8/callbacks#column
  We see there's a columnsResized callback
  in our python code in the options dict we can specify a javascript method

  assets/custom_tabulator.js
  ```javascript
  window.myNamespace = Object.assign({}, window.myNamespace, {
      tabulator: {
          columnResized : function (column, table) {
              // column is the tabulator column component
              // table is the tabulator instance, can be used for table.setProps() to send data back to dash
              console.log("Column is resized");
              console.log(column)

              // send data back to dash, still under work, only updates when state changes
              // be aware of table rendering and resetting back to original display
              table.props.setProps({"columnResized": column._column.field})
          }
      }
  });
  ```

  Within your python code, you can register this method as a tabulator option

  ```python
  from dash_extensions.javascript import Namespace
  ...
  ns = Namespace("CustomNamespace", "tabulator")
  ...
  options = { "groupBy": "col", "selectable":"true", "columnResized" : ns("columnResized")}
  ```

  A full list of callbacks available exists http://tabulator.info/docs/4.8/callbacks





  * Home Page https://github.com/preftech/dash-tabulator
  * Tabulator from @olifolkerd http://tabulator.info/
  * React-Tabulator from @ngduc https://github.com/ngduc/react-tabulator
  * Dash / Plotly from @plotly https://plotly.com/dash/


pkgId: e905c0adc025480b801e94cc98f4e6b6c1ab3a55b99e3bf986fdde49acaa8598
name: python-dash-uploader
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Upload large files using resumable.js
url: https://github.com/np-8/dash-uploader
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-uploader-0.6.1-1.src.rpm
checksum_type: sha256
description:
  ![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/np-8/dash-uploader)&nbsp;![PyPI](https://img.shields.io/pypi/v/dash-uploader)&nbsp;![PyPI - Downloads](https://img.shields.io/pypi/dm/dash-uploader)&nbsp;![GitHub](https://img.shields.io/github/license/np-8/dash-uploader)

  ![upload large files with dash-uploader](https://github.com/np-8/dash-uploader/blob/0.2.0/docs/upload-demo.gif?raw=true)


  The upload package for [Dash](https://dash.plotly.com/) applications using large data files.


  [https://github.com/np-8/dash-uploader](https://github.com/np-8/dash-uploader)



  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 💾 Data file size has no limits. (Except the hard disk size)<bR>
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ☎ Call easily a callback after uploading is finished.<br>
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 📦 Upload files using [resumable.js](https://github.com/23/resumable.js)
  <br>
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ✅ Works with Dash 1.1.0.+ & Python 3.6+. (Possibly with other versions, too)<br>




  ```
  pip install dash-uploader
  ```






  ```python
  import dash
  import dash_html_components as html
  import dash_uploader as du

  app = dash.Dash(__name__)


  du.configure_upload(app, r"C:\tmp\Uploads")


  app.layout = html.Div([
      du.Upload(),
  ])

  if __name__ == '__main__':
      app.run_server(debug=True)

  ```


pkgId: ff35526672add3cf88e3fdd13f3cb981fcfdba19689bded651f70c69282b1d69
name: python-dash-vega-components
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Dash Vega Components
url: https://pypi.org/project/dash-vega-components/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-vega-components-0.11.0-1.src.rpm
checksum_type: sha256
description:
  With the `Vega` component, you can display [Vega-Altair](https://altair-viz.github.io/) charts in your [Plotly Dash](https://dash.plotly.com/dash-vega-components) application. All features work as well with Vega-Lite and Vega specifications but the remainder of this README will focus on Altair as it is more common.

  You can either go through the examples below or head over to [the Plotly Dash documentation](https://dash.plotly.com/dash-vega-components) to learn more.


  ```bash
  pip install dash-vega-components
  ```


  For the example below, you'll also need:
  ```bash
  pip install altair vega_datasets
  ```

  ```python
  import altair as alt
  from dash import Dash, Input, Output, callback, dcc, html
  from vega_datasets import data

  import dash_vega_components as dvc


  app = Dash(
      __name__, external_stylesheets=["https://codepen.io/chriddyp/pen/bWLwgP.css"]
  )

  app.layout = html.Div(
      [
          html.H1("Altair Chart"),
          dcc.Dropdown(["All", "USA", "Europe", "Japan"], "All", id="origin-dropdown"),
          
          
          dvc.Vega(id="altair-chart", opt={"renderer": "svg", "actions": False}),
      ]
  )


  @callback(Output("altair-chart", "spec"), Input("origin-dropdown", "value"))
  def display_altair_chart(origin):
      source = data.cars()

      if origin != "All":
          source = source[source["Origin"] == origin]

      chart = (
          alt.Chart(source)
          .mark_circle(size=60)
          .encode(
              x="Horsepower",
              y="Miles_per_Gallon",
              color=alt.Color("Origin").scale(domain=["Europe", "Japan", "USA"]),
              tooltip=["Name", "Origin", "Horsepower", "Miles_per_Gallon"],
          )
          .interactive()
      )
      return chart.to_dict()


  if __name__ == "__main__":
      app.run(debug=True)
  ```
  ![Example](https://raw.githubusercontent.com/binste/dash-vega-components/main/dvc_example.gif)


  You can also pass a Vega or Vega-Lite specification as a dictionary.


  *Parameters* are the basic building blocks to make an Altair chart interactive. They can either be simple variables or more complex selections that map user input (e.g., mouse clicks and drags) to data queries. In Vega, these are called *Signals* and the two concepts of *Signals* and *Parameters* are closely linked. As an Altair user, you don't have to know the details and you can think of them as synonyms.

  You can trigger a Dash callback based on changes in any parameter which is defined in an Altair chart. To do this, you'll need to
  * specify a `name` when defining the parameter, for example `alt.param(name="my_param")` or `alt.selection_point(name="my_param")`
  * add the parameter name to the `signalsToObserve` property of the `Vega` component: `dvc.Vega(id="chart1", signalsToObserve=["my_param])`. If you want to observe all signals, you can also pass `signalsToObserve=["all"]`
  * use `Input("chart1", "signalData")` in your callback to access the value of `"my_param"` and react to changes

  For more examples, see [`example_app.py`](./example_app.py) which shows how to filter a pandas dataframe based on a selection in a chart and display it in a Dash data table (the same would work with the Dash AG Grid component), or head over to https://github.com/altair-viz/dash-vega-components/issues/5.

  Some ideas of what you could do with this:
  * Filter a Dash data table based on the selected points in a scatter plot (see [`example_app.py`](./example_app.py))
  * Based on a clickable bar chart, update other charts in your application
  * If you have geographic data, show an overview map of aggregated regional data. Use this map as a navigation element in a dash multi-page app so that if a user clicks on e.g. the US, they get to the US specific subpage
  * ...


  For more infos on the properites of the `Vega` component, see its docstring in [`Vega.py`](./dash_vega_components/Vega.py).

  To learn more about making Altair charts interactive, see [Interactive Charts - Vega-Altair docs](https://altair-viz.github.io/user_guide/interactions.html).

  If you want your chart to resize responsively, set `container="width"` in your Altair chart.


  Requires npm
  ```bash
  python -m venv .venv
  source .venv/bin/activate
  pip install -r requirements.txt
  pip install -r requirements-dev.txt

  npm install
  npm run build

  python example_app.py
  ```
  Visit http://localhost:8050 in your web browser

  To cut a new release, see [RELEASING.md](./RELEASING.md)

  This package is based on the [dash-component-boilerplate template](https://github.com/plotly/dash-component-boilerplate).


pkgId: 7fe8f3b6874d7e51aa4d350810b3759f892ca6060558cf80f337ccb85fbdd1f7
name: python-dash-vtk
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: React based declarative usage of vtk.js for Dash
url: https://github.com/plotly/dash-vtk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dash-vtk-0.0.9-1.src.rpm
checksum_type: sha256
description:
  *Dash VTK lets you integrate the `vtk.js` visualization pipeline directly into your Dash app. It is powered by [`react-vtk-js`](https://github.com/Kitware/react-vtk-js/).*


  | ![][usage-algorithm] | ![][pyvista-point-cloud] | ![][terrain-deformation] |
  | --- | --- | --- |
  | ![][volume-rendering] | ![][vtk-cfd] | ![][synthetic-volume] |

  * [Docs](https://github.com/plotly/dash-vtk/tree/master/docs)
  * [Demo Explorer](https://dash-gallery.plotly.host/dash-vtk-explorer/)
  * [Repository](https://github.com/plotly/dash-vtk)
  * [Webinar](https://go.plotly.com/dash-vtk)





  First, install the library through `pip`:
  ```
  pip install dash-vtk
  ```

  Then, create a file called `app.py` and add the following example:

  ```python
  import dash
  import dash_vtk
  import dash_html_components as html

  app = dash.Dash(__name__)

  app.layout = html.Div(
      style={"width": "100%", "height": "calc(100vh - 16px)"},
      children=dash_vtk.View([
          dash_vtk.GeometryRepresentation([
              dash_vtk.Algorithm(
                  vtkClass="vtkConeSource",
                  state={"resolution": 64, "capping": False},
              )
          ]),
      ]),
  )

  if __name__ == "__main__":
      app.run_server(debug=True)
  ```

  Now, simply run the app:
  ```
  python app.py
  ```

  For a more detailed example, see `usage.py`.



  First, install the package from GitHub (the package is not yet available via CRAN):
  ```
  remotes::install_github("plotly/dash-vtk")
  ```

  then, create your component and add it to your layout:

  ```r
  library(dash)
  library(dashVtk)
  library(dashHtmlComponents)

  app <- Dash$new()

  app$layout(htmlDiv(
      style = list("width" = "100%", "height" = "calc(100vh - 16px)"),
      children = vtkView(list(
          vtkGeometryRepresentation(
              vtkAlgorithm(
                  vtkClass = "vtkConeSource",
                  state = list("resolution" = 64, "capping" = FALSE),
              )
          )
      )
  )

  app$run_server()
  ```


  See [docs/CONTRIBUTING.md](./docs/CONTRIBUTING.md) to learn about:

  * Setting up the environment
  * Coding Style
  * Code quality & design
  * Tests
  * Publishing




  First clone the project (replace `<name>` with the desired demo):

  ``` bash
  git clone https://github.com/plotly/dash-vtk.git
  cd dash-vtk/demos/<name>/
  ```

  Create a venv and install the requirements:
  ```bash
  python -m venv venv
  source venv/bin/activate  # for Windows, use venv\Scripts\activate.bat
  pip install -e ../../  # IMPORTANT! If you skip you will get the pip version of dash-vtk
  pip install -r requirements.txt
  ```

  Run the demo:
  ```bash
  python app.py
  ```



  Depending on your Python environment, you may run into deployment issue related to the vtk version that get pulled in.

  Ideally we want a version of vtk equal or newer than 9. When using such version of VTK, `dash-vtk` won't even try to load the rendering module of VTK and if OpenGL is not available on your system everything will still be fine.

  On the other hand, if you are running python-3.6 and/or pip-18 or less and you don't upgrade your pip version, you will only be able to use `vtk<=8.1.2`. With vtk 8, there is no way to prevent the loading of the GL library which means that you will have to install libGL on your system, or you will run into errors like this:

  ```
    File ".../python/lib/python3.6/site-packages/vtkmodules/all.py", line 29, in <module>
      from .vtkRenderingOpenGL2 import *
  ImportError: libGL.so.1: cannot open shared object file: No such file or directory
  [2021-02-08 18:36:15 +0000] [10] [INFO] Worker exiting (pid: 10)
  ```

  or this:
  ```
    File ".../python3.7/site-packages/vtk/__init__.py", line 12, in <module>
      from .vtkOpenGLKit import *
    File ".../python3.7/site-packages/vtk/vtkOpenGLKit.py", line 9, in <module>
      from vtkOpenGLKitPython import *
  ModuleNotFoundError: No module named 'vtkOpenGLKitPython'
  ```

  Heroku and Dash Enterprise handle it is slightly different because you will have to install `libgl1-mesa-glx` via some `apt` files. In the case of Heroku, you will have to use a [buildpack](https://elements.heroku.com/buildpacks/heroku/heroku-buildpack-apt) and add `libgl1-mesa-glx` to a `Aptfile` located in the root of your project. In the case of Dash Enterprise, you do not need to change the buildpack (it is handled automatically) but you will need to add `libgl1-mesa-glx` to a `apt-packages` file instead of `Aptfile`; see [this app](https://github.com/plotly/dash-sample-apps/blob/master/apps/dash-vtk-explorer/apt-packages) as an example.



  You can find the complete API reference in [`docs/REFERENCES.md`](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md) for each of the following components:
  - [Algorithm](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#Algorithm)
  - [Calculator](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#Calculator)
  - [CellData](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#CellData)
  - [DataArray](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#DataArray)
  - [FieldData](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#FieldData)
  - [GeometryRepresentation](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#GeometryRepresentation)
  - [ImageData](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#ImageData)
  - [PointCloudRepresentation](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#PointCloudRepresentation)
  - [PointData](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#PointData)
  - [PolyData](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#PolyData)
  - [Reader](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#Reader)
  - [ShareDataSet](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#ShareDataSet)
  - [SliceRepresentation](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#SliceRepresentation)
  - [View](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#View)
  - [VolumeController](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#VolumeController)
  - [VolumeDataRepresentation](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#VolumeDataRepresentation)
  - [VolumeRepresentation](https://github.com/plotly/dash-vtk/blob/master/docs/REFERENCES.md#VolumeRepresentation)





  * [Code](https://github.com/plotly/dash-vtk/tree/master/demos/usage-algorithm)
  * [Online Demo](https://dash-gallery.plotly.host/dash-vtk-explorer/usage-algorithm)

  ![][usage-algorithm]



  * [Code](https://github.com/plotly/dash-vtk/tree/master/demos/pyvista-point-cloud)
  * [Online Demo](https://dash-gallery.plotly.host/dash-vtk-explorer/pyvista-point-cloud)

  ![][pyvista-point-cloud]



  * [Code](https://github.com/plotly/dash-vtk/tree/master/demos/pyvista-terrain-following-mesh)
  * [Online Demo](https://dash-gallery.plotly.host/dash-vtk-explorer/pyvista-terrain-following-mesh)

  ![][terrain-deformation]




  * [Code](https://github.com/plotly/dash-vtk/tree/master/demos/volume-rendering)
  * [Online Demo](https://dash-gallery.plotly.host/dash-vtk-explorer/volume-rendering)

  ![A demo of the volume-rendering app][volume-rendering]



  * [Code](https://github.com/plotly/dash-vtk/tree/master/demos/usage-vtk-cfd)
  * [Online Demo](https://dash-gallery.plotly.host/dash-vtk-explorer/usage-vtk-cfd)

  ![A demo of the usage-vtk-cfd app][vtk-cfd]



  * [Code](https://github.com/plotly/dash-vtk/tree/master/demos/synthetic-volume-rendering)
  * [Online Demo](https://dash-gallery.plotly.host/dash-vtk-explorer/synthetic-volume-rendering)

  ![A demo of the synthetic-volume-rendering app][synthetic-volume]

  [pyvista-point-cloud]: https://github.com/plotly/dash-vtk/blob/master/demos/pyvista-point-cloud/demo.jpg?raw=true
  [usage-algorithm]: https://github.com/plotly/dash-vtk/blob/master/demos/usage-algorithm/demo.jpg?raw=true
  [terrain-deformation]: https://github.com/plotly/dash-vtk/blob/master/demos/pyvista-terrain-following-mesh/demo.jpg?raw=true
  [volume-rendering]: https://github.com/plotly/dash-vtk/blob/master/demos/volume-rendering/demo.jpg?raw=true
  [vtk-cfd]: https://github.com/plotly/dash-vtk/blob/master/demos/usage-vtk-cfd/demo.jpg?raw=true
  [synthetic-volume]: https://github.com/plotly/dash-vtk/blob/master/demos/synthetic-volume-rendering/demo.jpg?raw=true
  [dicom-ct-lung]: https://github.com/plotly/dash-vtk/blob/master/demos/dicom-ct-lung/demo.jpg?raw=true
  [dicom-mri-brain]: https://github.com/plotly/dash-vtk/blob/master/demos/dicom-mri-brain/demo.jpg?raw=true
  [dicom-mri-pancreas]: https://github.com/plotly/dash-vtk/blob/master/demos/dicom-mri-pancreas/demo.jpg?raw=true


pkgId: 4a70a66b8c0cbed893e08c26f95c4ae45cf0677e73722f20987649fe531f4551
name: python-dashboard
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: An admin dashboard.
url: https://github.com/encode/dashboard
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dashboard-0.0.6-1.src.rpm
checksum_type: sha256
description:
  An admin dashboard for use with ASGI web frameworks.

  Work in progress.

  **example.py**

  ```python
  from starlette.applications import Starlette
  from starlette.routing import Mount, Route
  from starlette.responses import RedirectResponse
  from starlette.templating import Jinja2Templates
  from starlette.staticfiles import StaticFiles
  import databases
  import dashboard
  import orm
  import datetime


  database = databases.Database('sqlite:///test.db')
  models = orm.ModelRegistry(database=database)
  statics = StaticFiles(packages=['dashboard'])


  class Notes(orm.Model):
      registry = models
      tablename = 'notes'
      fields = {
          'id': orm.Integer(title="ID", primary_key=True, read_only=True),
          'created': orm.DateTime(title="Created", default=datetime.datetime.now, read_only=True),
          'text': orm.String(title="Text", max_length=100),
          'completed': orm.Boolean(title="Completed", default=False)
      }

  admin = dashboard.Dashboard(tables=[
      dashboard.DashboardTable(ident="notes", title="Notes", datasource=Notes.objects.order_by('-id')),
  ])


  routes = [
      Mount("/admin", app=admin, name='dashboard'),
      Mount("/statics", app=statics, name='static'),
      Route("/", endpoint=RedirectResponse(url='/admin')),
  ]

  app = Starlette(debug=True, routes=routes, on_startup=[database.connect], on_shutdown=[database.disconnect])
  ```

  Rough installation...

  ```shell
  $ virtualenv venv
  $ venv/bin/pip install dashboard
  $ venv/bin/python
  >>> from example import models
  >>> models.create_all()
  $ venv/bin/uvicorn example:app
  ```

  With many thanks to Eren Güven ([Twitter](https://twitter.com/cyberfart), [GitHub](https://github.com/eguven/)) for the `dashboard` PyPI package name.


pkgId: 704a432ed921ac60f88384b46d1218f8bf2360a08ed615cdc4aeb5283c37a906
name: python-dashboard-builder
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: A lightweight dashboard builder for data scientists.
url: https://pypi.org/project/dashboard-builder/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dashboard-builder-0.4.7-1.src.rpm
checksum_type: sha256
description:
  1. Complex example of Hospital and Centers for Medicare and Medicaid (CMS) Data for Long Island, New York. It is deployed via GCP Cloud Run, [please click here](https://dashboard-builder-cms-longisland-ua432tkhwq-uc.a.run.app/). The associated github source code for this repo can found here [https://github.com/hantswilliams/dashboard-builder-cms-longisland](https://github.com/hantswilliams/dashboard-builder-cms-longisland).

  - [ ] Add more output visualization components that include:
      - Folium
      - GGPlot
      - Bokeh
      - Seaborn
  - [ ] Add more input components that might include:
      - Date picker
      - File upload
      - Checkbox
      - Multi-select
      - Color picker
      - Number input
  - [x] Address matplotlib issue for rendering on web framework
  - [x] Add initial input components
  - [x] Add initial output components
  - [x] Create test files
  - [x] Add github actions for linting and secret checks
  - [x] Create build script
  - [x] Create at least one basic 'base' template for the dashboard view
  - [x] Incorporate some form of state management system
  - [x] Create a simple app examples
  - [x] Update below markdown/readme, double check it to make sure aligns with API
  - [x] Create docusuraus documentation site


pkgId: 9e7fed1ac345c2e95d426a1e2b91a6cf1b799b9cca11d4dfbaee9f440803d667
name: python-dashio
arch: src
version: 3.5.2
epoch: 0
release: 1
summary: DashIO interface library
url: https://dashio.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dashio-3.5.2-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/dashio-connect/python-dashio/actions/workflows/tests.yml/badge.svg)

  **[python-dashio](https://github.com/dashio-connect/python-dashio)** - Create beautiful mobile dashboards for your python project. The python-dashio library allows easy setup of controls such as Dials, Text Boxes, Charts, Graphs, and Notifications. You can define the look and layout of the controls on your phone from your python code. There are three methods to connect to your phone; Bluetooth Low Energy (BLE - on supported platforms), TCP, and MQTT via the dash.dashio.io server.



  * For the big picture on **DashIO**, take a look at our website: [dashio.io](https://dashio.io")

  * Create an account on [dash.dashio.io](https://dashio.io/account-create/)

  * Get the App:

  Apple              | Android
  :-----------------:|:------------------:
  [<img src=https://raw.githubusercontent.com/dashio-connect/python-dashio/master/Documents/download-on-the-app-store.svg width=200>](<https://apps.apple.com/us/app/dash-iot/id1574116689>) | [<img src=https://raw.githubusercontent.com/dashio-connect/python-dashio/master/Documents/Google_Play_Store_badge_EN.svg width=223>](<https://play.google.com/store/apps/details?id=com.dashio.dashiodashboard>)



  For all documentation and software guides: [dashio.io/documents](https://dashio.io/documents)

  For the **DashIO** Python guide: [dashio.io/guide-python](https://dashio.io/guide-python)

  For the **DashIO** Python library: [dashio.io/python-library]("https://dashio.io/python-library/)



  There are plenty of examples in the github repository under the Examples directory.



  The **Dash** app is free and available for both Apple and Android devices. Use it to create beautiful and powerful user interfaces to you IoT devices.

  Dashio Phone               |  Dashio Tablet
  :-------------------------:|:-------------------------:
  <img src="https://dashio.io/wp-content/uploads/2020/11/IMG_4154.jpeg" width="150" /> | <img src="https://dashio.io/wp-content/uploads/2020/12/IMG_4203.jpeg" width="450" />



  * python3.6 and above
  * paho-mqtt
  * pyzmq
  * python-dateutil
  * zeroconf
  * shortuuid



  `pip3 install dashio`

  Or

  ```sh
  git clone https://github.com/dashio-connect/python-dashio.git
  cd python-dashio
  pip3 install .
  ```



  This guide covers the **DashIO** python library. For information on the [***Dash***](https://dashio.io/dashboard) phone app please visit the website.



  So what is **DashIO**? It is a quick effortless way to connect your IoT device to your phone. It allows easy setup of controls such as Dials, Text Boxes, Maps, Graphs, Notifications..., from your Device. You can define the look and layout of the controls on your phone from your IoT device. There are three methods to connect to your phone tcp, mqtt, dash, and BLE. What's Dash then? Dash is a mqtt server with extra bits added in to allow you to send notifications, share your devices, and save your settings from your phone via the **Dash** app.

  Show me some code.

  ```python

  import dashio
  import random
  import time

  device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName")
  tcp_con = dashio.TCPConnection()
  tcp_con.add_device(device)
  first_dial_control = dashio.Dial("FirstDial")
  device.add_control(first_dial_control)

  while True:
      first_dial_control.dial_value = random.random() * 100
      time.sleep(5)
  ```

  This is about the fewest lines of code to get talking to the app. There is a lot happening under the hood to make this work. After the import we create a device with three attributes:

  * "aDeviceType": a common name device_type for all IoT devices using this code which is used for device discovery
  * "aDeviceID": a device_ID to uniquely identify this device, preferably a UUID.
  * "aDeviceName": The name of this device, which can be changed at any time.

  These attributes describe the device to the app and allow you to distinguish one of your devices from another.

  The next two lines create a TCP connection and then add the device to the connection. This device is discoverable by the Dash app. You can also discover your IoT device using a third party Bonjour/Zeroconf discovery tool. The mDNS service will be "DashIO.tcp."

  Though this device is discoverable by the app it would be nice to have the DashIO app automatically setup a new DeviceView and place your control on the new DeviceView. To do that we need to add a few more lines of code:

  ```python

  import dashio
  import random
  import time

  device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName")
  tcp_con = dashio.TCPConnection()
  tcp_con.add_device(device)
  first_dial_control = dashio.Dial("FirstDial", control_position=dashio.ControlPosition(0.24, 0.36, 0.54, 0.26))
  device.add_control(first_dial_control)

  dv_dial = dashio.DeviceView("aDeviceViewID", "A Dial")
  dv_dial.add_control(first_dial_control)
  device.add_control(dv_dial)

  while True:
      first_dial_control.dial_value = random.random() * 100
      time.sleep(5)
  ```

  First we altered the instantiation of a Dial by including a control_position. This allows us to place the control at a set location. The added lines instantiated a DeviceView control, which we than added the dial control. Finally we added the DeviceView to the device.

  The next piece of the puzzle to consider is how do we get data from the DashIO app? Lets add a Knob and connect it to the Dial:

  ```python

  import dashio
  import time

  device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName")
  tcp_con = dashio.TCPConnection()
  tcp_con.add_device(device)
  first_dial_control = dashio.Dial("FirstDial", control_position=dashio.ControlPosition(0.24, 0.36, 0.54, 0.26))
  device.add_control(first_dial_control)

  dv = dashio.DeviceView("aDeviceViewID", "A Dial")
  dv.add_control(first_dial_control)
  device.add_control(dv)

  def knob_event_handler(msg):
      first_dial_control.dial_value = float(msg[3])

  aknob = dashio.Knob("aKNB", control_position=dashio.ControlPosition(0.24, 0.14, 0.54, 0.26))
  aknob.add_receive_message_callback += knob_event_handler
  dv.add_control(aknob)
  device.add_control(aknob)

  while True:
      time.sleep(1)
  ```

  First we added a function that sets the dial value. Next we added a Knob control and added our new function to be called when it receives data from the DashIO app. We also add it to the DeviceView and to the device. Now when the knob in the DashIO app is moved the dial is set to the same value.



  The **Dash** app can generate a CFG64 text string that defines the controls, the controls layout, and device parameters for the Device. The CFG64 string can be used in a number of ways. If we run the example above and using the **Dash** app to export a layout we can use the layout to setup the device and controls.

  ```python

  import dashio
  import time

  cfg64 ="jVTbjpswEP2VlZ9RlWS7qcQbhJCNwiUCN6lU9YEFb7ACdmrMJukq/94xhpCbqr4NZ8bj4zlz+ETOPELmz18GmrgzZH4iVpcO+aAp"\
      "WVGyr5A5NFDWfMdE1jtkImSg9H0TkQ/InQy0CEIbGnyilDMpeDF3oCZZBDbU5YRuchklknJkDr6MxgaSVBZkySsKGINKO8Q49FGb"\
      "AMB6WjD+BkBFWBay4hiyiBQkqSApRU0MVFI4OICCnO99yvzkgMz3pKggJUi2SooaSr+9GGiXCMKkJtS/Cb7hSTQpfJ6pC93Q88I1"\
      "YIeOVk/4q4H2NJP5GXkBZAv8JrzgAg5HJGu7dYitrgdy8tg8Jwgj3/IAON51H0KvUpEfDgYnJYDXKhF7ThtZK0cHvrXUgY1nbeRP"\
      "g+86wtMfWEee7enAWa3WWhUpztTWOZXkKS759pKhbcXziRIVKm0uMiIe128EzSBTlwy2YjQyrgW/mS+FZJCUqn/8uwYdrhR2YF7d"\
      "jdsNy/rZJelWUcvhhL6rE13VYtXA5ofb8sscFgmrGuHTY7Ml56QLdGP6BxgMxxqGzenBEdTC7p9fOLzgd9/0hoGaTcSVXZ5HSkov"\
      "nLWmeo1wJ+oER52GOGhlmlteI9NOkJRWjSUG15N1qahkOzDg90bEhXu8qYsvpFzOp+ifa9+tW2+iHadM9pK321szKivt9QcevnaZ"\
      "Wn6XFuct05b4D5+3j3psu3u7PI8fmfHuJ6DGj2fR8lVN+PQX"

  config_dict = dashio.decode_cfg64(cfg64)
  device = dashio.Device("aDeviceType", "aDeviceID", "aDeviceName", cfg_dict=config_dict)
  tcp_con = dashio.TCPConnection()
  tcp_con.add_device(device)

  aknob: dashio.Knob = device.get_control(dashio.ControlName.KNOB, "aKNB")
  first_dial_control: dashio.Dial = device.get_control(dashio.ControlName.DIAL, "FirstDial")

  def knob_event_handler(msg):
      aknob.knob_dial_value = float(msg[3])
      first_dial_control.dial_value = float(msg[3])

  aknob.add_receive_message_callback(knob_event_handler)

  while True:
      time.sleep(1)
  ```

  We've added the cfg64 string. Then decoded it with *dashio.decode_cfg64(cfg64)*. This function returns a dictionary that we can pass into Device so that it can to instantiate and add the controls.

  Included in the library are two commandline utilities to encode and decode cfg64 files.

  ```sh
  $ c64_decode -h
  usage: c64_decode [-h] [-p] [-o OUT_FILE] [-i INDENT] file

  positional arguments:
    file                  Input file name.

  options:
    -h, --help            show this help message and exit
    -p, --print           Print output.
    -o OUT_FILE, --out OUT_FILE
                          output filename.
    -i INDENT, --indent INDENT
                          Indent depth (Default 4).
  ```

  And

  ```sh
  $ c64_encode -h
  usage: c64_encode [-h] [-f FORMAT] [-o OUT_FILE] [-w WIDTH] file

  positional arguments:
    file                  Input file name.

  options:
    -h, --help            show this help message and exit
    -f FORMAT, --format FORMAT
                          Format output. Options: 'None', 'C', 'Python'.
    -o OUT_FILE, --out OUT_FILE
                          output filename.
    -w WIDTH, --width WIDTH
                          Width of formatted output (Default 80).
  ```


pkgId: 8a3fd62e452e544366abd9e93e28f0c47e56db844cbffa9171469f1e904920c0
name: python-dashport
arch: src
version: 0.7.8
epoch: 0
release: 1
summary: Dashport curses wrapper for Python
url: https://github.com/numbertheory/dashport
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dashport-0.7.8-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/dashport.svg)](https://badge.fury.io/py/dashport) [![Documentation Status](https://readthedocs.org/projects/dashport/badge/?version=latest)](https://dashport.readthedocs.io/en/latest/?badge=latest)



  Dashport - An easy and safe way to use curses



  You can install from source code by cloning down this repo and running:

  ```
  pip install .
  ```

  Alternatively, use this to install from PyPI:

  ```
  pip install dashport
  ```


pkgId: 6aeaa651c0a7b4d5d293df2cf147674ea7b11f7a290a13f1f4078afb91a96bb0
name: python-dashscope
arch: src
version: 1.20.12
epoch: 0
release: 1
summary: dashscope client sdk library
url: https://dashscope.aliyun.com/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dashscope-1.20.12-1.src.rpm
checksum_type: sha256
description:
  <h4 align="center">
      <p>
          <b>English</b>
      <p>
  </h4>


  </div>




  To install the DashScope Python SDK, simply run:
  ```shell
  pip install dashscope
  ```

  If you clone the code from github, you can install from  source by running:
  ```shell
  pip install -e .
  ```

  To use tokenizer in local mode without downloading any files, run:
  ```shell
  pip install dashscope[tokenizer]
  ```




  You can use `Generation` api to call model qwen-turbo(通义千问).

  ```python
  from http import HTTPStatus
  import dashscope
  from dashscope import Generation

  dashscope.api_key = 'YOUR-DASHSCOPE-API-KEY'
  responses = Generation.call(model=Generation.Models.qwen_turbo,
                              prompt='今天天气好吗？')

  if responses.status_code == HTTPStatus.OK:
      print('Result is: %s' % responses.output)
  else:
      print('Failed request_id: %s, status_code: %s, code: %s, message:%s' %
              (responses.request_id, responses.status_code, responses.code,
              responses.message))

  ```



  The SDK uses API key for authentication. Please refer to [official documentation](https://dashscope.aliyun.com) regarding how to obtain your api-key.



  1. Set the API key via code
  ```python
  import dashscope

  dashscope.api_key = 'YOUR-DASHSCOPE-API-KEY'



  ```

  2. Set the API key via environment variables

  a. Set the API key directly using the environment variable below

  ```shell
  export DASHSCOPE_API_KEY='YOUR-DASHSCOPE-API-KEY'
  ```

  b. Specify the API key file path via an environment variable

  ```shell
  export DASHSCOPE_API_KEY_FILE_PATH='~/.dashscope/api_key'
  ```

  3. Save the API key to a file
  ```python
  from dashscope import save_api_key

  save_api_key(api_key='YOUR-DASHSCOPE-API-KEY',
               api_key_file_path='api_key_file_location or (None, will save to default location "~/.dashscope/api_key"')

  ```




  `call` function provides  synchronous call, the function call will return when computation is done on the server side.

  ```python
  from http import HTTPStatus
  from dashscope import Generation

  def sync_dashscope_sample():
      responses = Generation.call(
          model=Generation.Models.qwen_turbo,
          prompt='Is the weather good today?')

      if responses.status_code == HTTPStatus.OK:
          print('Result is: %s'%responses.output)
      else:
          print('Code: %s, status_code: %s, code: %s, message: %s')

  if __name__ == '__main__':
      sync_dashscope_sample()
  ```

  For requests with longer processing times, you can obtain partial results before the full output is generated. Set the **stream** parameter to **True**. In this case, the results will be returned in batches, and the current output mode is incremental (output will overwrite the previous content). When the output is in stream mode, the interface returns a generator, and you need to iterate through the generator to get the results. Each output contains partial data for streaming, and the last output contains the final generated result.

  Example with simple streaming:
  ```python
  from http import HTTPStatus
  from dashscope import Generation

  def sample_sync_call_stream():
      prompt_text = 'Give me a recipe using carrots, potatoes, and eggplants'
      response_generator = Generation.call(
          model=Generation.Models.qwen_turbo,
          prompt=prompt_text,
          stream=True,
          max_length=512,
          top_p=0.8)
      for resp in response_generator:  # Iterate through the streaming output results
          if resp.status_code == HTTPStatus.OK:
              print(resp.output)
          else:
              print('Request failed, message: %s'%resp.message)

  if __name__ == '__main__':
      sample_sync_call_stream()

  ```

  ```python
  from http import HTTPStatus
  from dashscope import Generation
  from dashscope.api_entities.dashscope_response import Role


  def stream_with_messages():
      messages = [{'role': Role.SYSTEM, 'content': 'You are a helpful assistant.'},
                  {'role': Role.USER, 'content': '如何做西红柿炖牛腩？'}]
      responses = Generation.call(
          Generation.Models.qwen_turbo,
          messages=messages,
          result_format='message',  # set the result to be "message" format.
          stream=True,
      )
      for response in responses:
         if response.status_code == HTTPStatus.OK:
             print(response)
         else:
             print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
                 response.request_id, response.status_code,
                 response.code, response.message
             ))

  if __name__ == '__main__':
      stream_with_messages()

  ```

  To output Dashscope logs, you need to configure the logger.
  ```shell
  export DASHSCOPE_LOGGING_LEVEL='info'

  ```


  The output contains the following fields:
  ```
       request_id (str): The request id.
       status_code (int): HTTP status code, 200 indicates that the
           request was successful, others indicate an error。
       code (str): Error code if error occurs, otherwise empty str.
       message (str): Set to error message on error.
       output (Any): The request output.
       usage (Any): The request usage information.
  ```


  Currently, errors are thrown as exceptions.



  Coming soon.



  This project is licensed under the Apache License (Version 2.0).


pkgId: ee60916aec31b830635885efac124834898a087b7208e4598f6f6ed4ddffd5d2
name: python-dashvis
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Dash Plotly implementation of vis.js library
url: https://github.com/lewkoo/dashvis
rpm_license: MIT, Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dashvis-0.1.14-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/lewkoo/dashvis">
      <img src="https://github.com/lewkoo/dashvis/blob/main/readme_images/DashVis_Logo.png?raw=true" alt="vis.js logo" width="500" height="200">
    </a>
  </p>

  <h3 align="center">DashVis Component</h3>

  <p align="center">
    Full implementation of vis.js network framework for Plotly Dash
    <br>
    <a href="https://visjs.github.io/vis-network/docs/network/">Explore the documentation</a>
    ·
    <a href="https://github.com/lewkoo/dashvis/issues/new?template=bug.md">Report a bug</a>
    ·
    <a href="https://github.com/lewkoo/dashvis/issues/new?template=feature.md">Request a feature</a>
    <br>
    <br>
    <img alt="GitHub Actions" src="https://github.com/facultyai/dash-bootstrap-components/workflows/Tests/badge.svg?branch=main">
    <img alt="GitHub" src="https://img.shields.io/github/license/lewkoo/dashvis">
    <img alt="npm" src="https://img.shields.io/npm/v/dashvis">
    <img alt="PyPI" src="https://img.shields.io/pypi/v/dashvis">
    <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/dashvis">
  </p>

  A full implementation of [vis.js][visjs-homepage] Network component for [Dash Plotly][dash-homepage]. Useful for displaying dynamic, automatically organised, customizable network views.



  - [Table of contents](#table-of-contents)
  - [Installation](#installation)
    - [PyPI](#pypi)
  - [Quick start](#quick-start)
  - [See how it is used](#see-how-it-is-used)
  - [Advanced examples](#advanced-examples)
  - [Linking a stylesheet](#linking-a-stylesheet)
  - [Contributing](#contributing)
  - [Future work 🔨](#future-work-)





  You can install _dashvis_ with `pip`:

  ```sh
  pip install dashvis
  ```



  _dashvis_ exposes a single component, _DashNetwork_. Simply create one and include it in your Dash layout. Simplest example:

  ```python
  import dash
  from dash import html
  from dashvis import DashNetwork

  app = dash.Dash()
  app.layout = html.Div([
      DashNetwork()
  ])

  if __name__ == '__main__':
      app.run_server(debug=True)
  ```



  A simple usage example is provided in `usage.py`.

  1. Run:
  ```shell
  python -m venv dashvis-venv
  source dashvis-venv/bin/activate
  pip install -r requirements.txt
  npm install
  npm run build
  python usage.py
  ```
  2. Visit <http://localhost:8050> in your web browser



  Examples which cover the entire API of `vis.js` are available in `usage_examples` folder.
  Running them requires PYTHONPATH to be made aware of `dashvis`.
  Simply run:
  ```shell
  export PYTHONPATH="${PYTHONPATH}:./dashvis"
  ````
  and then run any example from repo root directory of the repository:
  ```shell
  python usage_examples/<example_name>.py
  ```



  dashvis doesn't come with CSS included.
  If you enable network manipulation or navigation features, you need to include a stylesheet to draw those components of
  the network.

  For convenience, links to vis.js stylesheets are included for you and can be used as follows:

  ```python
  import dash
  import dashvis.stylesheets

  app = dash.Dash(external_stylesheets=[dashvis.stylesheets.VIS_NETWORK_STYLESHEET])
  ```



  See [CONTRIBUTING.md](./CONTRIBUTING.md)



  - [x] Update `usage.py`
  - [x] Fix two disabled `vis.js` function calls
  - [ ] Write tests
  - [ ] Add tests and code coverage badges
  - [x] Update this README

  [dash-homepage]: https://dash.plotly.com/
  [visjs-homepage]: https://visjs.github.io/vis-network/docs/network/
  [bug-report]: https://github.com/lewkoo/dashvis/issues/new?template=bug.md
  [feature-request]: https://github.com/lewkoo/dashvis/issues/new?template=feature.md
  [contribution-guide]: https://github.com/lewkoo/dashvis/blob/main/.github/CONTRIBUTING.md


pkgId: 4007778a9d2188b4eed7b98a115d9dabd441cfd5e1717d6f2da7484f95a5864c
name: python-dasi
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Automated DNA assembly planner for Python
url: https://github.com/jvrana/dasi-dna-design
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dasi-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/dasi.svg)](https://badge.fury.io/py/dasi)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  ![Build package](https://github.com/jvrana/DASi-DNA-Design/workflows/Build%20package/badge.svg)
  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/jvrana/DASi-DNA-Design.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/jvrana/DASi-DNA-Design/context:python)
  [![Total alerts](https://img.shields.io/lgtm/alerts/g/jvrana/DASi-DNA-Design.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/jvrana/DASi-DNA-Design/alerts/)

  **DASi** is an automatic DNA cloning plan designer aimed for operating on small budgets
  by focusing on material re-use.

  The software converts a nucleotide sequence, or a library of sequences, to an executable
   molecular assembly plan while optimizing material cost, assembly efficiency, and assembly time.

  The key design paradigm for DASi is that *no molecular biology expertise* is required to use DASi. Complete novices should be able to use the software to design and construct new genetic sequences. This also enables automated software programs to automatically design and construct new genetic sequences.

  The software goals are reminiscent of j5 or Teselegen but focused on:
  1. A dead-simple API usable by lab novices, experts or automated software programs.
  1. Utilizing information about current laboratory inventory in its optimization
  algorithm to minimize costs and turn-around time



  DASi is currently under development funded by the DARPA Synergistic Discovery and Design program. DASi is currently being used to connect automatically generate DNA designs to automated biological fabrication facilities (e.g. University of Washington Biofab).



  DASi completely automates the cloning design work, finding approximately optimal solutions for cloning steps, preferentially using existing plasmids, linear DNA fragments, and primers to design semi-optimal cloning steps and designs.

  The following command designs the cloning steps for a library of designs. The user only needs to specify the sequences they wish to construct and currently available primers and DNA templates as *.genbank* or *.fasta* files. DASi handles all design aspects. *No molecular biology expertise is required to use DASi.*

  ```bash
  dasi library_design --designs mydesigns/*.gb --fragments fragments/*.gb --primers primers.fasta --templates plasmids/*.gb --cost_model cost.b --out results
  ```



  DASi optimization parameters are completely customizable. The following are examples of parameters and aspects of DASi that are customizable:

  * primer synthesis costs
  * primer design parameters
  * synthetic fragment costs
  * vendor-specific synthetic fragment complexity
  * sequence dependent plasmid assembly efficiencies
  * optimizing over efficiency vs material costs
  * etc.



  * Golden-gate support
  * heirarchical assembly
  * library support (with bayesian search to optimize shared parts)
  * front-end
  * connection to fabrication facility



  Briefly, DASi approximates a solution the following optimization problem:

  ```Given a set of 'goal' double-stranded sequences, a set of available single-stranded and double-strand sequences, and a set of actions that can create new sequences, find the optimal set of operations that produces the 'goal' sequences.```

  Formalization of this optimization problem is coming soon.


pkgId: 6773ed9331136b89c96d1f65489565c255446bd7a2e99fa4c3377d29a56a3b65
name: python-dask
arch: src
version: 2024.9.0
epoch: 0
release: 1
summary: Parallel PyData with Task Scheduling
url: https://github.com/dask/dask/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-2024.9.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Coverage| |Doc Status| |Discourse| |Version Status| |NumFOCUS|
  Dask is a flexible parallel computing library for analytics.  See
  documentation_ for more information.


pkgId: 14c4c7877419b940591741b313a03a586aeda094ebdb93a6fa5982b43d7573e1
name: python-dask-awkward
arch: src
version: 2024.11.0
epoch: 0
release: 1
summary: Awkward Array meets Dask
url: https://github.com/dask-contrib/dask-awkward
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-awkward-2024.11.0-1.src.rpm
checksum_type: sha256
description:
  > Connecting [awkward-array](https://awkward-array.org) and
  [Dask](https://dask.org/).
  [![Tests](https://github.com/dask-contrib/dask-awkward/actions/workflows/pypi-tests.yml/badge.svg)](https://github.com/dask-contrib/dask-awkward/actions/workflows/pypi-tests.yml)
  [![Tests](https://github.com/dask-contrib/dask-awkward/actions/workflows/conda-tests.yml/badge.svg)](https://github.com/dask-contrib/dask-awkward/actions/workflows/conda-tests.yml)
  [![Documentation Status](https://readthedocs.org/projects/dask-awkward/badge/?version=latest)](https://dask-awkward.readthedocs.io/en/latest/?badge=latest)
  [![Coverage](https://codecov.io/gh/dask-contrib/dask-awkward/branch/main/graph/badge.svg)](https://codecov.io/gh/dask-contrib/dask-awkward/branch/main)
  [![PyPI](https://img.shields.io/pypi/v/dask-awkward?color=blue)](https://pypi.org/project/dask-awkward)
  [![Conda Forge](https://img.shields.io/conda/vn/conda-forge/dask-awkward.svg?colorB=486b87&style=flat)](https://anaconda.org/conda-forge/dask-awkward)


pkgId: 3b6c654494fc7c29044614c5f3ba2ae247338451eebe7f5e380f7960a59b16fa
name: python-dask-bigquery
arch: src
version: 2024.7.0
epoch: 0
release: 1
summary: Dask + BigQuery integration
url: https://pypi.org/project/dask-bigquery/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-bigquery-2024.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/coiled/dask-bigquery/actions/workflows/tests.yml/badge.svg)](https://github.com/coiled/dask-bigquery/actions/workflows/tests.yml) [![Linting](https://github.com/coiled/dask-bigquery/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/coiled/dask-bigquery/actions/workflows/pre-commit.yml)

  Read/write data from/to [Google BigQuery](https://cloud.google.com/bigquery) with Dask.

  This package uses the BigQuery Storage API. Please refer to the [data extraction pricing table](https://cloud.google.com/bigquery/pricing#data_extraction_pricing) for associated costs while using Dask-BigQuery.



  `dask-bigquery` can be installed with `pip`:

  ```
  pip install dask-bigquery
  ```

  or with `conda`:

  ```
  conda install -c conda-forge dask-bigquery
  ```



  For reading from BiqQuery, you need the following roles to be enabled on the account:

  - `BigQuery Read Session User`
  - `BigQuery Data Viewer`, `BigQuery Data Editor`, or `BigQuery Data Owner`

  Alternately, `BigQuery Admin` would give you full access to sessions and data.

  For writing to BigQuery, the following roles are sufficient:

  - `BigQuery Data Editor`
  - `Storage Object Creator`

  The minimal permissions to cover reading and writing:

  - `BigQuery Data Editor`
  - `BigQuery Read Session User`
  - `Storage Object Creator`



  By default, `dask-bigquery` will use the [Application Default Credentials](https://cloud.google.com/docs/authentication/provide-credentials-adc). When running code locally, you can set this to use your user credentials by running

  ```sh
  $ gcloud auth application-default login
  ```

  User credentials require interactive login. For settings where this isn't possible, you'll need to create a service account. You can set the Application Default Credentials to the service account key using the `GOOGLE_APPLICATION_CREDENTIALS` environment variable:

  ```sh
  $ export GOOGLE_APPLICATION_CREDENTIALS=/home/<username>/google.json
  ```

  For information on obtaining the credentials, use [Google API documentation](https://developers.google.com/workspace/guides/create-credentials).



  `dask-bigquery` assumes that you are already authenticated.

  ```python
  import dask_bigquery

  ddf = dask_bigquery.read_gbq(
      project_id="your_project_id",
      dataset_id="your_dataset",
      table_id="your_table",
  )

  ddf.head()
  ```





  Assuming that client and workers are already provisioned with default credentials:

  ```python
  import dask
  import dask_bigquery

  ddf = dask.datasets.timeseries(freq="1min")

  res = dask_bigquery.to_gbq(
      ddf,
      project_id="my_project_id",
      dataset_id="my_dataset_id",
      table_id="my_table_name",
  )
  ```

  Before loading data into BigQuery, `to_gbq` writes intermediary Parquet to a Google Storage bucket. Default bucket name is `<your_project_id>-dask-bigquery`. You can provide a diferent bucket name by setting the parameter: `bucket="my-gs-bucket"`. After the job is done, the intermediary data is deleted.



  ```python

  creds_dict = {"type": ..., "project_id": ..., "private_key_id": ...}

  res = to_gbq(
      ddf,
      project_id="my_project_id",
      dataset_id="my_dataset_id",
      table_id="my_table_name",
      credentials=credentials,
  )
  ```



  To run the tests locally you need to be authenticated and have a project created on that account. If you're using a service account, when created you need to select the role of "BigQuery Admin" in the section "Grant this service account access to project".

  You can run the tests with

  `$ pytest dask_bigquery`

  if your default `gcloud` project is set, or manually specify the project ID with

  `DASK_BIGQUERY_PROJECT_ID pytest dask_bigquery`



  This project stems from the discussion in
  [this Dask issue](https://github.com/dask/dask/issues/3121) and
  [this initial implementation](https://gist.github.com/bnaul/4819f045ccbee160b60a530b6cfc0c98#file-dask_bigquery-py)
  developed by [Brett Naul](https://github.com/bnaul), [Jacob Hayes](https://github.com/JacobHayes),
  and [Steven Soojin Kim](https://github.com/mikss).



  [BSD-3](LICENSE)


pkgId: 6d0d4c547842bde830bfff31c0950a713be2f9744bff5cc741e2b906e51d0601
name: python-dask-cloudprovider
arch: src
version: 2024.9.1
epoch: 0
release: 1
summary: Native Cloud Provider integration for Dask
url: https://github.com/dask/dask-cloudprovider
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-cloudprovider-2024.9.1-1.src.rpm
checksum_type: sha256
description:
  Native Cloud integration for Dask.
  This library provides tools to enable Dask clusters to more natively integrate with the cloud.
  It includes cluster managers to create dask clusters on a given cloud provider using native resources,
  plugins to more closely integrate Dask components with the cloud platform they are running on and documentation to empower all folks running Dask on the cloud.


pkgId: 80e64feeca21b3454c0f3c22e38ccd5b3a50aa7c4851a4ac8e7f7c4c7829b78b
name: python-dask-databricks
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/dask-databricks/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-databricks-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Cluster tools for running Dask on Databricks multi-node clusters.




  To launch a Dask cluster on Databricks you need to create an [init script](https://docs.databricks.com/en/init-scripts/index.html) with the following contents and configure your multi-node cluster to use it.

  ```bash



  /databricks/python/bin/pip install --upgrade dask[complete] dask-databricks


  dask databricks run
  ```

  Then from your Databricks Notebook you can quickly connect a Dask `Client` to the scheduler running on the Spark Driver Node.

  ```python
  import dask_databricks

  client = dask_databricks.get_client()
  ```

  Now you can submit work from your notebook to the multi-node Dask cluster.

  ```python
  def inc(x):
      return x + 1

  x = client.submit(inc, 10)
  x.result()
  ```



  You can access the [Dask dashboard](https://docs.dask.org/en/latest/dashboard.html) via the Databricks driver-node proxy. The link can be found in `Client` or `DatabricksCluster` repr or via `client.dashboard_link`.

  ```python
  >>> print(client.dashboard_link)
  https://dbc-dp-xxxx.cloud.databricks.com/driver-proxy/o/xxxx/xx-xxx-xxxx/8087/status
  ```

  ![](https://user-images.githubusercontent.com/1610850/281442274-450d41c6-2eb6-42a1-8de6-c4a1a1b84193.png)

  ![](https://user-images.githubusercontent.com/1610850/281441285-9b84d5f1-d58a-45dc-9354-7385e1599d1f.png)



  Releases of this project are automated using [GitHub Actions and the `pypa/gh-action-pypi-publish` action](https://github.com/dask-contrib/dask-databricks/blob/main/.github/workflows/release.yaml).

  To create a new release push a tag to the upstream repo in the format `x.x.x`. The package will be built and pushed to PyPI automatically and then later picked up by conda-forge.

  ```bash

  git remote add upstream git@github.com:dask-contrib/dask-databricks.git


  git tag x.x.x && git push upstream main --tags
  ```


pkgId: 91d9392220f13456236f0f515cc533c6be249c74ed9a7d0e6fd746cac4e36d72
name: python-dask-expr
arch: src
version: 1.1.14
epoch: 0
release: 1
summary: High Level Expressions for Dask
url: https://pypi.org/project/dask-expr/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-expr-1.1.14-1.src.rpm
checksum_type: sha256
description:
  Dask DataFrames with query optimization.
  This is a rewrite of Dask DataFrame that includes query
  optimization and generally improved organization.
  More in our blog posts:
  - [Dask Expressions overview](https://blog.dask.org/2023/08/25/dask-expr-introduction)
  - [TPC-H benchmark results vs. Dask DataFrame](https://docs.coiled.io/blog/tpch.html)


pkgId: be89511241b3c658d300edc8dfd8ecc3c075fd7b2b51ea95753c9267803f06b7
name: python-dask-felleskomponenter
arch: src
version: 0.0.29
epoch: 0
release: 1
summary: Felleskomponenter på DASK
url: https://github.com/kartverket/dask-modules/dask-felleskomponenter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-felleskomponenter-0.0.29-1.src.rpm
checksum_type: sha256
description:
  This is a repo where we make available governance components, common functions and reusable UDFs. DASK felleskomponenter is still in an early stage of the development process.

  You can find the PyPI package [here](https://pypi.org/project/dask-felleskomponenter/).



  You need to install Python3.7 and higher, and to install the dependencies of this project, please execute the following
  command

  ```bash
  pip install -r requirements.txt
  ```





  Navigate to the [Publish to PyPI](https://github.com/kartverket/dask-modules/actions/workflows/pypi-publish.yml) workflow in GitHub Actions, choose the `main` branch and bump the version.

  One member of Team DASK needs to approve the workflow run before it starts.



  - Remove old dist-folder, from last time you published
  - Update version in `setup.py`, for instance `0.0.7`->`0.0.8`
  - Add change info to CHANGES.txt
  - (Run `pip install -r requirements.txt` if you haven't done that earlier)
  - Run `python3 -m build` (and wait some minutes...)
  - Verity that dist contains a package with the new version in the package name.
  - Run `python3 -m twine upload dist/*` to upload to pypi



  Replace the last command with `python3 -m twine upload --repository testpypi dist/*`



  Use the following command

  ```sh
  coverage run -m unittest discover -s src/dask_felleskomponenter/tests
  coverage report -m
  ```


pkgId: c3e5c15ffeeb0d59aa126cf73ea053ec04b810224acde56074735372d8ba71a3
name: python-dask-geopandas
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Parallel GeoPandas with Dask
url: https://pypi.org/project/dask-geopandas/
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-geopandas-0.4.2-1.src.rpm
checksum_type: sha256
description:
  Parallel GeoPandas with Dask
  Dask-GeoPandas is a project merging the geospatial capabilities of GeoPandas
  and scalability of Dask. GeoPandas is an open source project designed to make working with geospatial data in Python easier. GeoPandas extends the datatypes used by pandas to allow spatial operations on geometric types.
  Dask provides advanced parallelism and distributed out-of-core computation with a dask.dataframe module designed to scale
  pandas. Since GeoPandas is an extension to the pandas DataFrame, the same way Dask scales pandas can also be applied to GeoPandas.
  This project is a bridge between Dask and GeoPandas and offers geospatial capabilities of GeoPandas backed by Dask.


pkgId: db7ac5c14496c10828d3e05d14d5560b2eb1e30ec14a8e3455e8da3433addd9c
name: python-dask-glm
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Generalized Linear Models with Dask
url: http://github.com/dask/dask-glm/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-glm-0.3.2-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Documentation Status|
  *This library is not ready for use.*
  See the `documentation`_ for more information.


pkgId: b79085f55d1c29209e079e9d3387fa0588d9de98801985eb323b3ddf95bb03fa
name: python-dask-histogram
arch: src
version: 2024.9.1
epoch: 0
release: 1
summary: Histogramming with Dask.
url: https://github.com/dask-contrib/dask-histogram
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-histogram-2024.9.1-1.src.rpm
checksum_type: sha256
description:
  > Scale up histogramming with [Dask](https://dask.org).

  [![Tests](https://github.com/dask-contrib/dask-histogram/actions/workflows/ci.yml/badge.svg)](https://github.com/dask-contrib/dask-histogram/actions/workflows/ci.yml)
  [![Documentation Status](https://readthedocs.org/projects/dask-histogram/badge/?version=latest)](https://dask-histogram.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://img.shields.io/pypi/v/dask-histogram.svg?colorB=486b87&style=flat)](https://pypi.org/project/dask-histogram/)
  [![Conda Forge](https://img.shields.io/conda/vn/conda-forge/dask-histogram.svg?colorB=486b87&style=flat)](https://anaconda.org/conda-forge/dask-histogram)
  [![Python Version](https://img.shields.io/pypi/pyversions/dask-histogram)](https://pypi.org/project/dask-histogram/)

  The [boost-histogram](https://github.com/scikit-hep/boost-histogram)
  library provides a performant object oriented API for histogramming in
  Python. Building on the foundation of boost-histogram, dask-histogram
  adds support for lazy calculations on Dask collections.

  See [the documentation](https://dask-histogram.readthedocs.io/) for
  examples and the API reference.


pkgId: 382a9ff3743480b75de149538132cc007190d23031d77e55a5e640eebe883ed7
name: python-dask-jobqueue
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Deploy Dask on job queuing systems like PBS, Slurm, SGE or LSF
url: https://jobqueue.dask.org
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-jobqueue-0.9.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Doc Status| |Version Status|
  Easy deployment of Dask Distributed on job queuing systems such as PBS, Slurm,
  or SGE.  See documentation_ for more information.


pkgId: 58dbc56c07e7c0be9cccaf837cd9f3d5a55fe7124e26aa123bf5329aa6ceece4
name: python-dask-kubernetes
arch: src
version: 2024.9.0
epoch: 0
release: 1
summary: Native Kubernetes integration for Dask
description: Native Kubernetes integration for Dask.
url: https://github.com/dask/dask-kubernetes
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-kubernetes-2024.9.0-1.src.rpm
checksum_type: sha256
rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Dask Developers, Yuvi Panda, Anaconda Inc, NVIDIA All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 4b95c1b1e9d21099693a138fd7fc50cfbbd4fa7ffb0873bd7103811370c612e7
name: python-dask-ml
arch: src
version: 2024.4.4
epoch: 0
release: 1
summary: A library for distributed and parallel machine learning
url: https://github.com/dask/dask-ml
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-ml-2024.4.4-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Azure Pipelines| |Coverage| |Doc Status| |Discourse| |Version Status| |NumFOCUS|
  Dask-ML provides scalable machine learning in Python using `Dask <https://dask.org/>`__ alongside popular machine learning libraries like `Scikit-Learn <http://scikit-learn.org/>`__, `XGBoost <https://ml.dask.org/xgboost.html>`__, and others.
  You can try Dask-ML on a small cloud instance by clicking the following button:

rpm_license:
  Copyright (c) 2017, Anaconda, Inc. and contributors All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  Neither the name of Anaconda nor the names of any contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: e8d4d74e99679b555386d2a10dced54f7308d63d090d50488973c53be0279307
name: python-dask-optuna
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Scaling Optuna with Dask
url: https://github.com/jrbourbeau/dask-optuna
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-optuna-0.0.2-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/jrbourbeau/dask-optuna/workflows/Tests/badge.svg)](https://github.com/jrbourbeau/dask-optuna/actions?query=workflow%3ATests+branch%3Amaster)
  [![Documentation](https://github.com/jrbourbeau/dask-optuna/workflows/Documentation/badge.svg)](https://github.com/jrbourbeau/dask-optuna/actions?query=workflow%3ADocumentation+branch%3Amaster)
  [![Pre-commit](https://github.com/jrbourbeau/dask-optuna/workflows/Pre-commit/badge.svg)](https://github.com/jrbourbeau/dask-optuna/actions?query=workflow%3APre-commit+branch%3Amaster)

  Dask-Optuna helps improve integration between [Optuna](https://optuna.org/) and [Dask](https://dask.org/)
  by leveraging Optuna's existing distributed optimization capabilities to run
  optimization trials in parallel on a Dask cluster. It does this by providing a
  Dask-compatible `dask_optuna.DaskStorage` storage class which wraps an
  Optuna storage class (e.g. Optuna's in-memory or sqlite storage) and can be used
  directly by Optuna. For example:

  ```python
  import optuna
  import joblib
  import dask.distributed
  import dask_optuna

  def objective(trial):
      x = trial.suggest_uniform("x", -10, 10)
      return (x - 2) ** 2

  with dask.distributed.Client() as client:
      
      storage = dask_optuna.DaskStorage()
      study = optuna.create_study(storage=storage)
      
      with joblib.parallel_backend("dask"):
          study.optimize(objective, n_trials=100, n_jobs=-1)
      print(f"best_params = {study.best_params}")
  ```




  See the [Dask-Optuna documentation](https://jrbourbeau.github.io/dask-optuna) for more information.




  [MIT License](LICENSE)


pkgId: b87ccc69feaeefb6c807e7c1984a4c21a32b03702c934ba0dd07243b632d29bd
name: python-dask-remote-jobqueue
arch: src
version: 0.4.21
epoch: 0
release: 1
summary: Remote jobqueu implementation for DASK: create a scheduler on a remote job queue cluster
url: http://github.com/dodas-ts/dask-remote-jobqueue
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-remote-jobqueue-0.4.21-1.src.rpm
checksum_type: sha256
description:
  <!--
   Copyright (c) 2021 dciangot

   This software is released under the MIT License.
   https://opensource.org/licenses/MIT
  -->



  A custom dask remote jobqueue for HTCondor


pkgId: 857e39a1afee541f0e6bdb454a9caeb7978f291fa5d5894abd92c72abc8ecf40
name: python-dask-saturn
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Dask Cluster objects in Saturn Cloud
url: https://saturncloud.io/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-saturn-0.4.4-1.src.rpm
checksum_type: sha256
description:
  Python library for interacting with [Dask](https://dask.org/) clusters in
  [Saturn Cloud](https://www.saturncloud.io/).

  Dask-Saturn mimics the API of
  [Dask-Kubernetes](https://github.com/dask/dask-kubernetes), but allows the user
  to interact with clusters created within
  [Saturn Cloud](https://www.saturncloud.io/).


  From within a Jupyter notebook, you can start a cluster:

  ```python
  from dask_saturn import SaturnCluster

  cluster = SaturnCluster()
  cluster
  ```

  By default this will start a dask cluster with the same settings that you have
  already set in the Saturn UI or in a prior notebook.

  To start the cluster with a certain number of workers using the `n_workers`
  option. Similarly, you can set the `scheduler_size`, `worker_size`, and `worker_is_spot`.

  > Note: If the cluster is already running then you can't change the settings.
  > Attempting to do so will raise a warning.

  Use the `shudown_on_close` option to set up a cluster that is tied to the client
  kernel. This functions like a regular dask `LocalCluster`, when your jupyter
  kernel dies or is restarted, the dask cluster will close.


  Once you have a cluster you can interact with it via the jupyter
  widget, or using the `scale` and `adapt` methods.

  For example, to manually scale up to 20 workers:

  ```python
  cluster.scale(20)
  ```

  To create an adaptive cluster that controls its own scaling:

  ```python
  cluster.adapt(minimum=1, maximum=20)
  ```


  To submit tasks to the cluster, you sometimes need access to the
  `Client` object. Instantiate this with the cluster as the only argument:

  ```python
  from distributed import Client

  client = Client(cluster)
  client
  ```



  To terminate all resources associated with a cluster, use the
  `close` method:

  ```python
  cluster.close()
  ```



  To update the settings (such as `n_workers`, `worker_size`, `worker_is_spot`, `nthreads`) on an existing cluster, use the `reset` method:

  ```python
  cluster.reset(n_workers=3)
  ```

  You can also call this without instantiating the cluster first:

  ```python
  cluster = SaturnCluster.reset(n_workers=3)
  ```

  By default, you'll get one worker, but you can change that using the `n_workers` option. Similarly you can override the scheduler and worker hardware settings with `scheduler_size`, `worker_size`. You can display the available size options using `describe_sizes()`:

  ```python
  >>> describe_sizes()
  {'medium': 'Medium - 2 cores - 4 GB RAM',
   'large': 'Large - 2 cores - 16 GB RAM',
   'xlarge': 'XLarge - 4 cores - 32 GB RAM',
   '2xlarge': '2XLarge - 8 cores - 64 GB RAM',
   '4xlarge': '4XLarge - 16 cores - 128 GB RAM',
   '8xlarge': '8XLarge - 32 cores - 256 GB RAM',
   '12xlarge': '12XLarge - 48 cores - 384 GB RAM',
   '16xlarge': '16XLarge - 64 cores - 512 GB RAM',
   'g4dnxlarge': 'T4-XLarge - 4 cores - 16 GB RAM - 1 GPU',
   'g4dn4xlarge': 'T4-4XLarge - 16 cores - 64 GB RAM - 1 GPU',
   'g4dn8xlarge': 'T4-8XLarge - 32 cores - 128 GB RAM - 1 GPU',
   'p32xlarge': 'V100-2XLarge - 8 cores - 61 GB RAM - 1 GPU',
   'p38xlarge': 'V100-8XLarge - 32 cores - 244 GB RAM - 4 GPU',
   'p316xlarge': 'V100-16XLarge - 64 cores - 488 GB RAM - 8 GPU'}
  ```

  Here's an example:

  ```python
  cluster = SaturnCluster(
      scheduler_size="large",
      worker_size="2xlarge",
      n_workers=3,
  )
  client = Client(cluster)
  client
  ```



  To connect to your Dask cluster from outside of Saturn, you need to set two environment variables: ``SATURN_TOKEN`` and ``SATURN_BASE_URL``.

  To get the values for these you'll need to go Saturn in your browser. Go to where you want to connect a Dask cluster. There will be a button that says:
  "Connect Externally". Clicking that will open a modal with the values for ``SATURN_TOKEN`` and ``SATURN_BASE_URL``

  Remember - that token is private so don't share it with anyone! It'll be a something like `351e6f2d40bf4d15a0009fc086c602df`

  ```sh
  export SATURN_BASE_URL="https://app.demo.saturnenterprise.io"
  export SATURN_TOKEN="351e6f2d40bf4d15a0009fc086c602df"
  ```

  After you have set the environment variables, you can open a Python session and connect to your Dask cluster just as you would inside of Saturn:

  ```python
  from dask_saturn import SaturnCluster
  from distributed import Client

  cluster = SaturnCluster()
  client = Client(cluster)
  client
  ```

  When you are done working with the dask cluster make sure to shut it down:

  ```python
  cluster.close()
  ```



  When working with distributed dask clusters, the workers don't have access to the same file system as your client does. So you will see files in your jupyter server that aren't available on the workers. To move files to the workers you can use the `RegisterFiles` plugin and call `sync_files` on any path that you want to update on the workers.

  For instance if you have a file structure like:
  ```
  /home/jovyan/project/
  |---- utils/
  |   |---- __init__.py
  |   |---- hello.py
  |
  |---- Untitled.ipynb
  ```

  where hello.py contains:

  ```python

  def greet():
      return "Hello"
  ```

  If the code in hello.py changes or you add new files to utils, you'll want to push those changes to the workers. After setting up the `SaturnCluster` and the `Client`, register the `RegisterFiles` plugin with the workers. Then every time you make changes to the files in utils, run `sync_files`. The worker plugin makes sure that any new worker that comes up will have any files that you have synced.

  ```python
  from dask_saturn import RegisterFiles, sync_files

  client.register_worker_plugin(RegisterFiles())
  sync_files(client, "utils")


  client.restart()


  from util.hello import greet
  client.run(greet)
  ```

  > TIP: You can always check the state of the filesystem on your workers by running `client.run(os.listdir)`



  Create/update a dask-saturn conda environment:

  ```sh
  make conda-update
  ```

  Set environment variables to run dask-saturn with a local atlas server:

  ```sh
  export SATURN_BASE_URL=http://dev.localtest.me:8888/
  export SATURN_TOKEN=<JUPYTER_SERVER_SATURN_TOKEN>
  ```


pkgId: 9df0755db4c39a06eba8ddcb82c7b2d78601a66bac99a7751596aa1930445ec3
name: python-dask-searchcv
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Tools for doing hyperparameter search with Scikit-Learn and Dask
url: http://github.com/dask/dask-searchcv
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-searchcv-0.2.0-1.src.rpm
checksum_type: sha256
description:
  |Travis Status| |Doc Status| |Conda Badge| |PyPI Badge|
  Tools for performing hyperparameter search with
  `Scikit-Learn <http://scikit-learn.org>`_ and `Dask <http://dask.pydata.org>`_.


pkgId: 60eac50e0d0b8c88ab4579e33849709946b5e819816450b66e85c84c57802305
name: python-dask-snowflake
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Dask + Snowflake intergration
url: https://pypi.org/project/dask-snowflake/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-snowflake-0.3.3-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/coiled/dask-snowflake/actions/workflows/tests.yml/badge.svg)](https://github.com/coiled/dask-snowflake/actions/workflows/tests.yml)
  [![Linting](https://github.com/coiled/dask-snowflake/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/coiled/dask-snowflake/actions/workflows/pre-commit.yml)

  This connector is in an early experimental/testing phase.

  [Reach out to us](https://coiled.io/contact-us/) if you are interested in trying
  it out!



  `dask-snowflake` can be installed with `pip`:

  ```shell
  pip install dask-snowflake
  ```

  or with `conda`:

  ```shell
  conda install -c conda-forge dask-snowflake
  ```



  `dask-snowflake` provides `read_snowflake` and `to_snowflake` methods
  for parallel IO from Snowflake with Dask.

  ```python
  >>> from dask_snowflake import read_snowflake
  >>> example_query = '''
  ...    SELECT *
  ...    FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER;
  ... '''
  >>> ddf = read_snowflake(
  ...     query=example_query,
  ...     connection_kwargs={
  ...         "user": "...",
  ...         "password": "...",
  ...         "account": "...",
  ...     },
  ... )
  ```

  ```python
  >>> from dask_snowflake import to_snowflake
  >>> to_snowflake(
  ...     ddf,
  ...     name="my_table",
  ...     connection_kwargs={
  ...         "user": "...",
  ...         "password": "...",
  ...         "account": "...",
  ...     },
  ... )
  ```

  See their docstrings for further API information.



  Running tests requires a Snowflake account and access to a database.
  The test suite will automatically look for specific `SNOWFLAKE_*`
  environment variables (listed below) that must be set.

  It's recommended (though not required) to store these environment variables
  in a local `.env` file in the root of the `dask-snowflake` repository.
  This file will be automatically ignored by `git`, reducing the risk of accidentally
  commiting it.

  Here's what an example `.env` file looks like:

  ```env
  SNOWFLAKE_USER="<test user name>"
  SNOWFLAKE_PASSWORD="<test_user_password>"
  SNOWFLAKE_ACCOUNT="<account>.<region>.aws"
  SNOWFLAKE_WAREHOUSE="<test warehouse>"
  SNOWFLAKE_ROLE="<test role>"
  SNOWFLAKE_DATABASE="<test database>"
  SNOWFLAKE_SCHEMA="<test schema>"
  ```

  You may then `source .env` or install [`pytest-dotenv`](https://github.com/quiqua/pytest-dotenv)
  to automatically set these environment variables.

  > **_Note:_**
  > If you run the tests and get an `MemoryError` mentioning
  > "write+execute memory for ffi.callback()", you probably have stale
  > build of `cffi` from conda-forge. Remove it and install the version
  > using `pip`:
  >
  > ```shell
  > conda remove cffi --force
  > pip install cffi
  > ```



  [BSD-3](LICENSE)


pkgId: b119a68a954c726fdce0e310a6189ec0b3eaa3638fecf6a500133d205de719e9
name: python-dask-sphinx-theme
arch: src
version: 3.0.5
epoch: 0
release: 1
summary: Dask theme for Sphinx
url: https://github.com/dask/dask-sphinx-theme/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-sphinx-theme-3.0.5-1.src.rpm
checksum_type: sha256
description:
  This is the official Sphinx theme for Dask documentation.  It extends the
  ``sphinx-book-theme`` project, but adds custom styling and a navigation bar to
  additional Dask subprojects.
  When creating a Dask subproject you can include this theme by changing this
  line in your conf.py file
     html_theme = 'dask_sphinx_theme'
  And by including ``dask_sphinx_theme`` as a requirement in your documentation
  installation.


pkgId: 9e53140607eecfa6917a6db204f039e9eaebcedbfb54d0e2803d037cc18f713a
name: python-dask-xgboost
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Interactions between Dask and XGBoost
url: https://github.com/dask/dask-xgboost
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-xgboost-0.2.0-1.src.rpm
checksum_type: sha256
description:
     Dask-XGBoost has been deprecated and is no longer maintained. The functionality
     of this project has been included directly in XGBoost. To use Dask and XGBoost
     together, please use ``xgboost.dask`` instead
     https://xgboost.readthedocs.io/en/latest/tutorials/dask.html.
  Distributed training with XGBoost and Dask.distributed
  This repository offers a legacy option to perform distributed training
  with XGBoost on Dask.array and Dask.dataframe collections.
     pip install dask-xgboost
  Please note that XGBoost now includes a Dask API as part of its official Python package.
  That API is independent of `dask-xgboost` and is now the recommended way to use Dask
  adn XGBoost together. See
  `the xgb.dask documentation here https://xgboost.readthedocs.io/en/latest/tutorials/dask.html`
  for more details on the new API.


pkgId: cc453fc5ab2116616e6543afe6b2b1d11ebd288608213a0b077e1769641b5b5e
name: python-dask-yarn
arch: src
version: 0.9
epoch: 0
release: 1
summary: Deploy dask clusters on Apache YARN
url: https://pypi.org/project/dask-yarn/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dask-yarn-0.9-1.src.rpm
checksum_type: sha256
description:
  |travis| |readthedocs| |pypi| |conda|
  Dask-Yarn deploys Dask on `YARN
  <https://hadoop.apache.org/docs/current/hadoop-yarn/hadoop-yarn-site/YARN.html>`_
  clusters, such as are found in traditional Hadoop installations. Dask-Yarn
  provides an easy interface to quickly start, stop, and scale Dask clusters
  natively from Python.
  See `the documentation <http://yarn.dask.org>`_ for more information.


pkgId: c326c1a5dbf3709c0a5f177abe300311d64abf3a4cb91f335c7c82f446f46407
name: python-dasoundlib
arch: src
version: 0.5
epoch: 0
release: 1
summary: A package to generate and play sine wave sounds
url: https://github.com/ForNoOne401/Soundlib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dasoundlib-0.5-1.src.rpm
checksum_type: sha256
description:
  ░██████╗░█████╗░██╗░░░██╗███╗░░██╗██████╗░██╗░░░░░██╗██████╗░
  ██╔════╝██╔══██╗██║░░░██║████╗░██║██╔══██╗██║░░░░░██║██╔══██╗
  ╚█████╗░██║░░██║██║░░░██║██╔██╗██║██║░░██║██║░░░░░██║██████╦╝
  ░╚═══██╗██║░░██║██║░░░██║██║╚████║██║░░██║██║░░░░░██║██╔══██╗
  ██████╔╝╚█████╔╝╚██████╔╝██║░╚███║██████╔╝███████╗██║██████╦╝
  ╚═════╝░░╚════╝░░╚═════╝░╚═╝░░╚══╝╚═════╝░╚══════╝╚═╝╚═════╝░

  The Soundlib module is a versatile Python extension designed to generate and play sine wave sounds. Soundlib seamlessly integrates with Python to offer flexible and real-time audio playback.


  ```python
  from soundlib import *
  play_sound(<frequency>, <milliseconds>)
  ```


pkgId: 17c6156c49056eb258e25f5cfe2ad3d53c9f4c6fee3fbe4cc361ba2b98446d1d
name: python-daspython
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: DAS api client.
url: https://git.nioz.nl/ict-projects/das-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-daspython-4.0.2-1.src.rpm
checksum_type: sha256
description:
  The [Royal Netherlands Institute for Sea Research](https://www.nioz.nl) has its data management system to help scientists archive and access their data. This tool is called: **Data Archive System (DAS)** and this package is its Python client.

  _*NOTE: This package requires Python 3.11 and plus*_



  ```
      $ pip install daspython
  ```






  ```
      $ pip install virtualenv
  ```


  ```
      $ virtualenv .venv
  ```


  ```
      $ .\.venv\Scripts\activate.ps1
  ```


  ```
      $ deactivate
  ```




  ```powershell
      $ pip install -r .\requirements.txt
  ```

  The best way to see how each method is used is visiting out [automated test scripts](https://git.nioz.nl/ict-projects/das-python/-/tree/master/tests) page.



  Use this class to authenticate and keep your token that will be needed to use with all other service classes.



  ```python
  from daspython.auth.authenticate import DasAuth

  auth = DasAuth('DAS url', 'Your user name', 'Your password')

  if (auth.authenticate()):
      print('You are connected ...')
  ```



  ```
  python -m unittest tests/test_something.py
  ```



  ```
  $ pip install twine
  ```

  ```
  twine upload dist/*
  ```
  Than follow the instructions to publish/upload the distribution files to pypi.org


pkgId: 1a016566be1dde3b87d73cae7fe71055e9db5f6f912b2f9474f684193a6eff7c
name: python-dat1-cli
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/dat1-cli/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dat1-cli-0.0.8-1.src.rpm
checksum_type: sha256
description:
  A command line interface for the [dat1](dat1.co) platform.



  ```bash
  pip install dat1-cli
  ```




  Initialize with your API key:

  ```bash
  dat1 login
  ```

  To initialize a new model project, run in the root directory of your project:

  ```bash
  dat1 init
  ```

  To upload your model to the platform:

  ```bash
  dat1 deploy
  ```

  A good starting point for your model is using the [example model](https://github.com/dat1-co/dat1-docker/tree/main/example).

  Otherwise, the platform expects a `handler.py` file in the root directory of your project that contains a FastAPI app with two endpoints: GET `/` for healthchecks and POST `/infer` for inference.
  An example handler is shown below:

  ```python
  from fastapi import Request, FastAPI
  from vllm import LLM, SamplingParams
  import os

  llm = LLM(model=os.path.expanduser('./'), load_format="safetensors", enforce_eager=True)

  app = FastAPI()

  @app.get("/")
  async def root():
      return "OK"

  @app.post("/infer")
  async def infer(request: Request):
      request = await request.json()
      prompts = request["prompt"]
      sampling_params = SamplingParams(temperature=0.8, top_p=0.95)
      outputs = llm.generate(prompts, sampling_params)
      return { "response" : outputs[0].outputs[0].text }
  ```





  - Docker
  - CUDA-compatible GPU
  - NVIDIA Container Toolkit

  To launch your model locally, run:

  ```bash
  dat1 serve
  ```



  MIT


pkgId: e996e850b9fbfb23df97f9eb7184dc799c87e3dd404fde6a9d41b591e65c112e
name: python-dat1-cli
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/dat1-cli/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dat1-cli-0.1.1-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/dat1-cli)

  A command line interface for the [dat1](dat1.co) platform.



  ```bash
  pip install dat1-cli
  ```




  Initialize with your API key:

  ```bash
  dat1 login
  ```

  To initialize a new model project, run in the root directory of your project:

  ```bash
  dat1 init
  ```

  To upload your model to the platform:

  ```bash
  dat1 deploy
  ```

  A good starting point for your model is using the [example model](https://github.com/dat1-co/dat1-docker/tree/main/example).

  Otherwise, the platform expects a `handler.py` file in the root directory of your project that contains a FastAPI app with two endpoints: GET `/` for healthchecks and POST `/infer` for inference.
  An example handler is shown below:

  ```python
  from fastapi import Request, FastAPI
  from vllm import LLM, SamplingParams
  import os

  llm = LLM(model=os.path.expanduser('./'), load_format="safetensors", enforce_eager=True)

  app = FastAPI()

  @app.get("/")
  async def root():
      return "OK"

  @app.post("/infer")
  async def infer(request: Request):
      request = await request.json()
      prompts = request["prompt"]
      sampling_params = SamplingParams(temperature=0.8, top_p=0.95)
      outputs = llm.generate(prompts, sampling_params)
      return { "response" : outputs[0].outputs[0].text }
  ```





  - Docker
  - CUDA-compatible GPU
  - NVIDIA Container Toolkit

  To launch your model locally, run:

  ```bash
  dat1 serve
  ```



  MIT


pkgId: 4cb865052a1d46a5b14d7497bb9b195845971b2b8d49aa65affdef59cba07e99
name: python-data
arch: src
version: 0.4
epoch: 0
release: 1
summary: Work with unicode/non-unicode data from files or strings uniformly.
url: http://github.com/mbr/data
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data-0.4-1.src.rpm
checksum_type: sha256
description:
  ``data`` is a small Python module that allows you to treat input in a singular
  way and leave it up to the caller to supply a byte-string, a unicode object, a
  file-like or a filename.
      >>> open('helloworld.txt', 'w').write('hello, world from a file')
      >>> from data import Data as I
      >>> a = I(u'hello, world')
      >>> b = I(file='helloworld.txt')
      >>> c = I(open('helloworld.txt'))
      >>> print unicode(a)
      hello, world
      >>> print unicode(b)
      hello, world from a file
      >>> print unicode(c)
      hello, world from a file
  This can be made even more convenient using the ``data`` decorator:
      >>> from data.decorators import data
      >>> @data('buf')
      >>> parse_buffer('hello')
      "buf passed in as Data(data='hello', encoding='utf8')"
      >>> rv = parse_buffer(open('helloworld.txt'))
      >>> assert 'file=' in rv


pkgId: 64be74dc478f2fd5a82063ebea1daa3f355c3b665725e63b5713bba24c77eac9
name: python-data-agent
arch: src
version: 0.3.2
epoch: 0
release: 1
url: https://github.com/imubit/data-agent/
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data-agent-0.3.2-1.src.rpm
checksum_type: sha256
summary:
  Data Agent is a python library for pipelining real-time and historical data to and from industrial historians and control systems

description:
  [![PyPI-Server](https://img.shields.io/pypi/v/data-agent.svg)](https://pypi.org/project/data-agent/)
  [![Coveralls](https://img.shields.io/coveralls/github/imubit/data-agent/main.svg)](https://coveralls.io/r/imubit/data-agent)





  Python package for accessing real-time and historical data on industrial historians and control systems.
  Different historian protocols and APIs are implemented through standalone plugins.

  *THIS PACKAGE IS USELESS WITHOUT EXTERNAL PLUGINS IMPLEMENTING TARGET SYSTEM CUSTOM DATA ACCESS PROTOCOLS*



  The package provides a unified data access API having several usage scenarios:

  * As a Python package
  * As a command line CLI
  * As a service (Windows or Linux) using AMQ protocol



  ```commandline
  pip install data-agent
  ```

  Install the plugins required for communicating with the target systems



  ```python
  from data_agent.local_agent import LocalAgent

  with LocalAgent() as agent:

      agent.api.list_supported_connectors()
      agent.api.create_connection(...)
  ```




  ```bash
  dagent --service.id my_service --broker.uri amqp://guest:guest@192.168.4.23/
  ```


pkgId: 5702694023ceec9d69498c4964877f9d13e6780be31b3a9d62f4a2db82811e6e
name: python-data-agent-aspen-ip21
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Aspen IP21 historian plugin for `data-agent` package
url: https://github.com/imubit/data-agent-aspen-ip21/
rpm_license: LGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data-agent-aspen-ip21-0.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Built Status](https://api.cirrus-ci.com/github/imubit/data-agent-aspen-ip21.svg?branch=main)](https://cirrus-ci.com/github/imubit/data-agent-aspen-ip21)
  [![PyPI-Server](https://img.shields.io/pypi/v/data-agent-aspen-ip21.svg)](https://pypi.org/project/data-agent-aspen-ip21/)
  [![Project generated with PyScaffold](https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold)](https://pyscaffold.org/)



  > Data Agent plugin for AspenTech InfoPlus.21

  The plugin allows Data Extractor do access data on IP21 systems using ODBC connection.


pkgId: aca1ebb5059e6197ff052d9682f36f72e5b977a06b484445119bd63713018db1
name: python-data-algebra
arch: src
version: 1.7.1
epoch: 0
release: 1
url: https://github.com/WinVector/data_algebra
rpm_license: License :: OSI Approved :: BSD 3-clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data-algebra-1.7.1-1.src.rpm
checksum_type: sha256
summary:
  data_algebra is a data manipulation language that can both generate SQL queries and work on Pandas DataFrames.

description:
  [data_algebra](https://github.com/WinVector/data_algebra) is a piped data wrangling system
  based on Codd's relational algebra and experience working with data manipulation languages at scale.
  The primary purpose of the package is to support an easy to
  compose and maintain grammar of data processing steps that in turn can be used to generate
  database specific SQL. The package also implements the same transforms for Pandas and Polars DataFrames.

  Currently the system is primarily adapted and testing for Pandas, Polars, Google BigQuery, PostgreSQL, SQLite, Spark, and
  MySQL.

  [R](https://www.r-project.org) versions of the system are available as
  the [rquery](https://github.com/WinVector/rquery) and
  [rqdatatable](https://github.com/WinVector/rqdatatable) packages.


pkgId: ff6c791a3a570280118b4db1d6689db803f53df89c206c9688fb2da3e4e67bdc
name: python-data-analysis-helper
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/data-analysis-helper/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data-analysis-helper-0.12.0-1.src.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [data analysis helper](#data-analysis-helper)
    - [Installation](#installation)
      - [pip (recommended)](#pip-recommended)
      - [conda](#conda)
    - [License](#license)


  ```console
  pip install data_analysis_helper
  ```
  When installing with pip, it will not automatically install all dependencies, allowing selectively choosing dependencies when using only parts of this library. So pip is the recommended way to install this library.

  ```console
  conda install laf070810::data_analysis_helper
  ```
  When installing with conda, dependencies which are needed by any part of this library will be installed.

  `data-analysis-helper` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: ed0c6236546f83bab7f044adef16097c175830a072c9973afdab76425beacca8
name: python-data-api-mapper
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: A very simplistic AWS Aurora Serverless Data API mapper
url: https://github.com/get-carefull/data-api-mapper
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data-api-mapper-1.2.4-1.src.rpm
checksum_type: sha256
description:
  The **Data API Mapper** is a lightweight wrapper for Amazon Aurora Serverless Data API. It's STRONGLY inspired by [DataApiClient](https://github.com/jeremydaly/data-api-client).
  Currently, it only maps PostgreSQL types, but it can be easily extended to add MySQL.


  Check https://github.com/jeremydaly/data-api-client#why-do-i-need-this



  ```python
  import os
  import boto3
  from data_api_mapper import DataAPIClient

  db_name = os.getenv('DB_NAME')
  db_cluster_arn = os.getenv('DB_CLUSTER_ARN')
  secret_arn = os.getenv('SECRET_ARN')

  rds_client = boto3.client('rds-data')
  data_client = DataAPIClient(rds_client, secret_arn, db_cluster_arn, db_name)
  ```


  Once initialized, running a query is super simple. Use the `query()` method and pass in your SQL statement:

  ```python
  result = data_client.query('SELECT * FROM myTable')
  ```

  By default, this will return your rows as an array of dictionaries with column names as key names and the values as values, converted to python types:
  For example, for this database:
  ```sql
  CREATE TABLE aurora_data_api_test (
      id SERIAL,
      a_name TEXT,
      doc JSONB DEFAULT '{}',
      num_numeric NUMERIC (10, 5) DEFAULT 0.0,
      num_float float,
      num_integer integer,
      ts TIMESTAMP WITH TIME ZONE,
      field_string_null TEXT NULL,
      field_long_null integer NULL,
      field_doc_null JSONB NULL,
      field_boolean BOOLEAN NULL,
      tz_notimezone TIMESTAMP,
      a_date DATE
  );
  INSERT INTO aurora_data_api_test (a_name, doc, num_numeric, num_float, num_integer, ts, tz_notimezone, a_date)
  VALUES ('first row', '{"string_vale": "string1", "int_value": 1, "float_value": 1.11}', 1.12345, 1.11, 1, '1976-11-02 08:45:00 UTC', '2021-03-03 15:51:48.082288', '1976-11-02');
  VALUES ('second row', '{"string_vale": "string2", "int_value": 2, "float_value": 2.22}', 2.22, 2.22, 2, '1976-11-02 08:45:00 UTC', '2021-03-03 15:51:48.082288', '1976-11-02');
  ```
  this query
  ```pyton
  self.data_client.query("select * from aurora_data_api_test where id (1,2)"
  ```
  will return:
  ```python
  [{'id': 1, 'a_name': 'first row', 'doc': {'int_value': 1, 'float_value': 1.11, 'string_vale': 'string1'}, 'num_numeric': Decimal('1.12345'), 'num_float': 1.11, 'num_integer': 1, 'ts': datetime.datetime(1976, 11, 2, 8, 45, tzinfo=datetime.timezone.utc), 'field_string_null': None, 'field_long_null': None, 'field_doc_null': None, 'field_boolean': None, 'tz_notimezone': datetime.datetime(2021, 3, 3, 15, 51, 48, 82288, tzinfo=datetime.timezone.utc), 'a_date': datetime.date(1976, 11, 2)},
   {'id': 2, 'a_name': 'prueba', 'doc': {'a_date': '1976-11-02', 'num_int': 1, 'num_float': 45.6, 'somestring': 'hello'}, 'num_numeric': Decimal('100.76540'), 'num_float': 10.123, 'num_integer': 1, 'ts': datetime.datetime(1976, 11, 2, 8, 45, tzinfo=datetime.timezone.utc), 'field_string_null': None, 'field_long_null': None, 'field_doc_null': None, 'field_boolean': True, 'tz_notimezone': datetime.datetime(2021, 3, 3, 15, 51, 48, 82288, tzinfo=datetime.timezone.utc), 'a_date': datetime.date(1976, 11, 2)}]
  ```


  By default, `query()` receives a dictionary that maps PostgreSQL types to python types.
  ```python
  POSTGRES_PYTHON_MAPPER = {
      'jsonb': JsonbToDict,
      'timestamptz': TimestampzToDatetimeUTC,
      'timestamp': TimestampzToDatetimeUTC,
      'date': DateToDate,
      'numeric': NumericToDecimal,
  }

  class DataAPIClient:

      def __init__(self, rds_client, secret_arn, cluster_arn, database_name) -> None:
          ...
      def query(self, sql, parameters=None, mapper=POSTGRES_PYTHON_MAPPER):
          ...

  ```

  There is also a mapper for AppSync, you can check the mappers [here](https://github.com/get-carefull/data-api-mapper/blob/master/data_api_mapper/converters.py).
  <br>
  If you use MySQL you need a mapper.





  To query with parameters, you can use named parameters in your SQL, and then provide an object containing your parameters as the second argument to the `query()` method and the client does the conversion for you:

  ```python
  import datetime
  result = data_client.query(
      'SELECT * FROM myTable WHERE id = :id AND created > :createDate',
      { 'id': 2, 'createDate': datetime.date(2021,6,1) }
  )
  ```
  For all the conversions, check [here](https://github.com/get-carefull/data-api-mapper/blob/master/data_api_mapper/data_api.py#L10)



  ```python
  class TestDataAPI(unittest.TestCase):

      data_client = None

      @classmethod
      def setUpClass(cls):
          db_name = os.getenv('DB_NAME')
          db_cluster_arn = os.getenv('DB_CLUSTER_ARN')
          secret_arn = os.getenv('SECRET_ARN')
          rds_client = boto3.client('rds-data')
          data_client = DataAPIClient(rds_client, secret_arn, db_cluster_arn, db_name)
          initial_sql = """
              DROP TABLE IF EXISTS aurora_data_api_test;
              CREATE TABLE aurora_data_api_test (
                  id SERIAL,
                  a_name TEXT,
                  doc JSONB DEFAULT '{}',
                  num_numeric NUMERIC (10, 5) DEFAULT 0.0,
                  num_float float,
                  num_integer integer,
                  ts TIMESTAMP WITH TIME ZONE,
                  field_string_null TEXT NULL,
                  field_long_null integer NULL,
                  field_doc_null JSONB NULL,
                  field_boolean BOOLEAN NULL,
                  tz_notimezone TIMESTAMP,
                  a_date DATE
              );
              INSERT INTO aurora_data_api_test (a_name, doc, num_numeric, num_float, num_integer, ts, tz_notimezone, a_date)
              VALUES ('first row', '{"string_vale": "string1", "int_value": 1, "float_value": 1.11}', 1.12345, 1.11, 1, '1976-11-02 08:45:00 UTC', '2021-03-03 15:51:48.082288', '1976-11-02');
              VALUES ('second row', '{"string_vale": "string2", "int_value": 2, "float_value": 2.22}', 2.22, 2.22, 2, '1976-11-02 08:45:00 UTC', '2021-03-03 15:51:48.082288', '1976-11-02');
          """
          data_client.query(sql=initial_sql)
          cls.data_client = data_client

      def test_transaction(self):
          transaction = self.data_client.begin_transaction()
          transaction.query('''
              INSERT INTO aurora_data_api_test (id, a_name, doc, num_numeric, num_float, num_integer, ts, tz_notimezone)
              VALUES (345, 'first row', '{"string_vale": "string1", "int_value": 1, "float_value": 1.11}', 1.12345, 1.11, 1, '1976-11-02 08:45:00 UTC', '2021-03-03 15:51:48.082288');
          ''')
          inside_transaction = transaction.query("select * from aurora_data_api_test where id = 345")
          self.assertEqual(1, len(inside_transaction))
          transaction.query('''
              INSERT INTO aurora_data_api_test (id, a_name, doc, num_numeric, num_float, num_integer, ts, tz_notimezone)
              VALUES (346, 'first row', '{"string_vale": "string1", "int_value": 1, "float_value": 1.11}', 1.12345, 1.11, 1, '1976-11-02 08:45:00 UTC', '2021-03-03 15:51:48.082288');
          ''')
          inside_transaction = transaction.query("select * from aurora_data_api_test where id in (345,346)")
          self.assertEqual(2, len(inside_transaction))
          before_commit = self.data_client.query("select * from aurora_data_api_test where id in (345,346)")
          self.assertEqual(0, len(before_commit))
          transaction.commit()
          after_commit = self.data_client.query("select * from aurora_data_api_test where id in (345,346)")
          self.assertEqual(2, len(after_commit))

      def test_transaction_rollback(self):
          transaction = self.data_client.begin_transaction()
          transaction.query('''
              INSERT INTO aurora_data_api_test (id, a_name, doc, num_numeric, num_float, num_integer, ts, tz_notimezone)
              VALUES (355, 'first row', '{"string_vale": "string1", "int_value": 1, "float_value": 1.11}', 1.12345, 1.11, 1, '1976-11-02 08:45:00 UTC', '2021-03-03 15:51:48.082288')
          ''')
          inside_transaction = transaction.query("select * from aurora_data_api_test where id = 355")
          self.assertEqual(1, len(inside_transaction))
          transaction.query('''
              INSERT INTO aurora_data_api_test (id, a_name, doc, num_numeric, num_float, num_integer, ts, tz_notimezone)
              VALUES (356, 'first row', '{"string_vale": "string1", "int_value": 1, "float_value": 1.11}', 1.12345, 1.11, 1, '1976-11-02 08:45:00 UTC', '2021-03-03 15:51:48.082288')
          ''')
          inside_transaction = transaction.query("select * from aurora_data_api_test where id in (355,356)")
          self.assertEqual(2, len(inside_transaction))
          before_rollback = self.data_client.query("select * from aurora_data_api_test where id in (355,356)")
          self.assertEqual(0, len(before_rollback))
          transaction.rollback()
          after_rollback = self.data_client.query("select * from aurora_data_api_test where id in (355,356)")
          self.assertEqual(0, len(after_rollback))

      @classmethod
      def tearDownClass(cls):
          cls.data_client.query('DROP TABLE IF EXISTS aurora_data_api_test')
  ```


pkgId: e2710406936cd4ec0343536756329904c37f2ba253559a46bb82f0f42336e14f
name: python-data-cache
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Data Cache
url: https://github.com/statnett/data_cache
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data-cache-0.1.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/data-cache)](https://pypi.org/project/data-cache/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/data-cache)](https://pypi.org/project/data-cache/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![](https://github.com/statnett/data_cache/workflows/Tests/badge.svg)](https://github.com/statnett/data_cache/actions?query=workflow%3ATests)
  [![codecov](https://codecov.io/gh/statnett/data_cache/branch/master/graph/badge.svg)](https://codecov.io/gh/statnett/data_cache)



  Works by hashing the combinations of arguments of a function call with
  the function name to create a unique id of a table retrieval.  If
  the function call is new the original function will be called, and the
  resulting tables(s) will be stored in a HDFStore indexed by the
  hashed key.  Next time the function is called with the same args the
  tables(s) will be retrieved from the store instead of executing the
  function.

  The hashing of the arguments is done by first applying str() on the
  argument, and then taking th md5 hash of the combination of these args
  together with the function name.  This means that if a argument for
  some reason does not have a str representation the key generation will
  fail.  To omit this issue one can specify which arguments the cache
  should consider such that 'un-stringable' arguments are skipped.  This
  functionality is also used for skipping arguments the should by design
  not be considered for the key-generation like for example
  database-clients.




  The module automatically creates a `cache/data.h5` relative to
  `__main__`, to change this set the environment variable
  `CACHE_PATH` to be the desired directory of the `data.h5` file.



  To disable the cache set the environment variable
  `DISABLE_CACHE` to `TRUE`.





  ```python
  from data_cache import pandas_cache
  from time import sleep
  from datetime import datetime
  import pandas as pd

  @pandas_cache
  def simple_func():
      sleep(5)
      return pd.DataFrame([[1,2,3], [2,3,4]])


  t0 = datetime.now()
  print(simple_func())
  print(datetime.now() - t0)

  t0 = datetime.now()
  print(simple_func())
  print(datetime.now() - t0)
  ```
  ```commandline
     0  1  2
  0  1  2  3
  1  2  3  4
  0:00:05.343027
     0  1  2
  0  1  2  3
  1  2  3  4
  0:00:00.015987
  ```



  The decorator ignores arguments named 'self' such that it will work across different instances of the same object.

  ```python
  from data_cache import pandas_cache
  from time import sleep
  from datetime import datetime
  import pandas as pd


  class PandasClass:
      def __init__(self):
          print(self)

      @pandas_cache
      def simple_func(self):
          sleep(5)
          return pd.DataFrame([[1,2,3], [2,3,4]])

  c = PandasClass()
  t0 = datetime.now()
  print(c.simple_func())
  print(datetime.now() - t0)

  c = PandasClass()
  t0 = datetime.now()
  print(c.simple_func())
  print(datetime.now() - t0)
  ```
  ```commandline
  <__main__.PandasClass object at 0x003451F0>
     0  1  2
  0  1  2  3
  1  2  3  4
  0:00:05.375342
  <__main__.PandasClass object at 0x124814B0>
     0  1  2
  0  1  2  3
  1  2  3  4
  0:00:00.014959
  ```



  ```python
  from data_cache import pandas_cache
  from time import sleep
  from datetime import datetime
  import pandas as pd

  @pandas_cache("a", "c")
  def simple_func(a, b, c=True):
      sleep(5)
      return pd.DataFrame([[1,2,3], [2,3,4]])


  t0 = datetime.now()
  print(simple_func(a=1, b=2))
  print(datetime.now() - t0)


  t0 = datetime.now()
  print(simple_func(a=1, b=3))
  print(datetime.now() - t0)
  ```
  ```commandline
     0  1  2
  0  1  2  3
  1  2  3  4
  0:00:05.619620
     0  1  2
  0  1  2  3
  1  2  3  4
  0:00:00.017980
  ```



  ```python
  from data_cache import pandas_cache
  from time import sleep
  from datetime import datetime
  import pandas as pd


  @pandas_cache("a", "c")
  def simple_func(a, *args, **kwargs):
      sleep(5)
      return pd.DataFrame([[1,2,3], [2,3,4]]), pd.DataFrame([[1,2,3], [2,3,4]]) * 10


  t0 = datetime.now()
  print(simple_func(1, b=2, c=True))
  print(datetime.now() - t0)

  t0 = datetime.now()
  print(simple_func(a=1, b=3, c=True))
  print(datetime.now() - t0)
  ```
  ```commandline
  (   0  1  2
  0  1  2  3
  1  2  3  4,     0   1   2
  0  10  20  30
  1  20  30  40)
  0:00:05.368545
  (   0  1  2
  0  1  2  3
  1  2  3  4,     0   1   2
  0  10  20  30
  1  20  30  40)
  0:00:00.019578
  ```



  Caching can be disabled using the environment variable DISABLE_CACHE to TRUE

  ```python
  from mock import patch
  def test_cached_function():
      with patch.dict("os.environ", {"DISABLE_CACHE": "TRUE"}, clear=True):
          assert cached_function() == target
  ```



  ```python
  from data_cache import numpy_cache
  from time import sleep
  from datetime import datetime
  import numpy as np


  @numpy_cache("a", "c")
  def simple_func(a, *args, **kwargs):
      sleep(5)
      return np.array([[1, 2, 3], [2, 3, 4]]), np.array([[1, 2, 3], [2, 3, 4]]) * 10


  t0 = datetime.now()
  print(simple_func(1, b=2, c=True))
  print(datetime.now() - t0)

  t0 = datetime.now()
  print(simple_func(a=1, b=3, c=True))
  print(datetime.now() - t0)
  ```

  ```commandline
  (array([[1, 2, 3],
         [2, 3, 4]]), array([[10, 20, 30],
         [20, 30, 40]]))
  0:00:05.009084
  (array([[1, 2, 3],
         [2, 3, 4]]), array([[10, 20, 30],
         [20, 30, 40]]))
  0:00:00.002000
  ```



  Metadata is automatically stored with the data on the group node containing the
  DataFrame/Array.

  ```python
  from data_cache import numpy_cache, pandas_cache, read_metadata
  import pandas as pd
  import numpy as np
  from datetime import datetime


  @pandas_cache
  def function1(a, *args, b=1, **kwargs):
      return pd.DataFrame()

  @numpy_cache
  def function2(a, *args, b=1, **kwargs):
      return np.array([])

  function1(1, True, datetime.date(2019, 11, 11))
  function2(2, False, b=2, c=1.1)
  read_metadata("path_to_data.h5")
  ```
  results:
  ```json
  {
      "/a86f0a323bf20998b5deda81e9f90bb49/a5d320e5dcdc5d3f35a4ca366980b2dc1": {
          "a": "1",
          "arglist": "(True, datetime.date(2019, 11, 11))",
          "b": "1",
          "date_stored": "01/05/2020, 10:00:00",
          "function_name": "function1",
          "module_path": "path_to_module"
      },
      "/a56ad8af46bc5fd8b9320b00b12e6c115/a62734531fc99855292c9db04d5eba60a": {
          "a": "2",
          "arglist": "(False,)",
          "b": "2",
          "c": "1.1",
          "date_stored": "01/05/2020, 10:00:00",
          "function_name": "function2",
          "module_path":  "path_to_module"
      }
  }
  ```


pkgId: 82c343e926f155879ff868d2e84792ed08dbf380396fba12c43529e12e181d20
name: python-data2rdf
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: A generic pipeline that can be used to map raw data to RDF.
url: https://github.com/MI-FraunhoferIWM/data2rdf
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data2rdf-2.2.1-1.src.rpm
checksum_type: sha256
description:
  A pipeline for generating data representation in RDF out of raw data given in ASCII, CSV, JSON or EXCEL format.

  https://data2rdf.readthedocs.io/en/latest/

  <!-- Pytest Coverage Comment:Begin -->
  <a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/README.md"><img alt="Coverage" src="https://img.shields.io/badge/Coverage-88%25-green.svg" /></a><details><summary>Coverage Report </summary><table><tr><th>File</th><th>Stmts</th><th>Miss</th><th>Cover</th><th>Missing</th></tr><tbody><tr><td colspan="5"><b>data2rdf</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/__init__.py">__init__.py</a></td><td>5</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/config.py">config.py</a></td><td>19</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/utils.py">utils.py</a></td><td>8</td><td>1</td><td>1</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/utils.py#L 88%"> 88%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/warnings.py">warnings.py</a></td><td>2</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td colspan="5"><b>data2rdf/models</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/__init__.py">__init__.py</a></td><td>3</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/base.py">base.py</a></td><td>54</td><td>5</td><td>5</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/base.py#L 91%"> 91%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/graph.py">graph.py</a></td><td>100</td><td>7</td><td>7</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/graph.py#L 93%"> 93%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/mapping.py">mapping.py</a></td><td>39</td><td>1</td><td>1</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/mapping.py#L 97%"> 97%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/utils.py">utils.py</a></td><td>58</td><td>14</td><td>14</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/utils.py#L 76%"> 76%</a></td></tr><tr><td colspan="5"><b>data2rdf/modes</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/modes/__init__.py">__init__.py</a></td><td>4</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td colspan="5"><b>data2rdf/parsers</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/__init__.py">__init__.py</a></td><td>6</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/base.py">base.py</a></td><td>135</td><td>11</td><td>11</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/base.py#L 92%"> 92%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/csv.py">csv.py</a></td><td>168</td><td>20</td><td>20</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/csv.py#L 88%"> 88%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/excel.py">excel.py</a></td><td>174</td><td>17</td><td>17</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/excel.py#L 90%"> 90%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/json.py">json.py</a></td><td>205</td><td>37</td><td>37</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/json.py#L 82%"> 82%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/utils.py">utils.py</a></td><td>88</td><td>10</td><td>10</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/utils.py#L 89%"> 89%</a></td></tr><tr><td colspan="5"><b>data2rdf/pipelines</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/pipelines/__init__.py">__init__.py</a></td><td>2</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/pipelines/main.py">main.py</a></td><td>82</td><td>9</td><td>9</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/pipelines/main.py#L 89%"> 89%</a></td></tr><tr><td colspan="5"><b>data2rdf/qudt</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/qudt/__init__.py">__init__.py</a></td><td>0</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/qudt/utils.py">utils.py</a></td><td>42</td><td>12</td><td>12</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/qudt/utils.py#L 71%"> 71%</a></td></tr><tr><td><b>TOTAL</b></td><td><b>1194</b></td><td><b>144</b></td><td><b>88%</b></td><td>&nbsp;</td></tr></tbody></table></details>
  <!-- Pytest Coverage Comment:End -->





  Either install the package from the pypi

  ```bash
  pip install data2rdf
  ```



  Install the package from the source code:
  ```bash
  git clone git@github.com:MI-FraunhoferIWM/data2rdf.git
  cd data2rdf
  pip install -e .
  ```



  Before running the unit tests, please install the needed packages:

  ```{bash}
  pip install data2rdf[tests]
  ```

  Afterwards, run the unittest with:

  ```{bash}
  pytest
  ```




  A server will start, generate the docs and listen for changes in the source files.
  This can be done by using docker or installing the development environment directly on the you machine. Next are installation guides for Docker and Linux OS.



  First, build the Docker image by running the following command:

  ```shell
  $ docker build -f docs.Dockerfile -t data2rdf-docs .
  ```

  Then, start the program by running:

  ```shell
  $ docker run -it --rm -v $PWD:/app -p 8000:8000 data2rdf-docs
  ```



  At an OS level (these commands work on Linux Debian):

  ```shell
  $ sudo apt install pandoc graphviz default-jre
  $ sudo apt-get install texlive-latex-recommended \
                         texlive-latex-extra \
                         texlive-fonts-recommended \
                         latexmk
  ```

  The python dependencies:

  ```shell
  $ pip install .[docs]
  ```

  Now you can start the server and render the docs:

  ```
  $ sphinx-autobuild docs/source docs/build/html
  ```

  The documentation will be available on [`http://127.0.0.1:8000`](http://127.0.0.1:8000).



  To generate a PDF of the documentation, simply run (from the root project folder):

  ```sh
  make -C docs latexpdf
  ```

  The generated PDF can be found under docs/build/latex/data2rdf_docs.pdf


pkgId: 7087d47d51868299433a95f9d3dc7cfc6e4226c506f2f9211a35c29176e8fbdb
name: python-data2rdf
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: A generic pipeline that can be used to map raw data to RDF.
url: https://github.com/MI-FraunhoferIWM/data2rdf
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data2rdf-2.3.0-1.src.rpm
checksum_type: sha256
description:
  A pipeline for generating data representation in RDF out of raw data given in ASCII, CSV, JSON or EXCEL format.

  https://data2rdf.readthedocs.io/en/latest/

  <!-- Pytest Coverage Comment:Begin -->
  <a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/README.md"><img alt="Coverage" src="https://img.shields.io/badge/Coverage-88%25-green.svg" /></a><details><summary>Coverage Report </summary><table><tr><th>File</th><th>Stmts</th><th>Miss</th><th>Cover</th><th>Missing</th></tr><tbody><tr><td colspan="5"><b>data2rdf</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/__init__.py">__init__.py</a></td><td>5</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/config.py">config.py</a></td><td>26</td><td>1</td><td>1</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/config.py#L 96%"> 96%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/utils.py">utils.py</a></td><td>8</td><td>1</td><td>1</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/utils.py#L 88%"> 88%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/warnings.py">warnings.py</a></td><td>2</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td colspan="5"><b>data2rdf/models</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/__init__.py">__init__.py</a></td><td>3</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/base.py">base.py</a></td><td>54</td><td>5</td><td>5</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/base.py#L 91%"> 91%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/graph.py">graph.py</a></td><td>119</td><td>7</td><td>7</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/graph.py#L 94%"> 94%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/mapping.py">mapping.py</a></td><td>45</td><td>1</td><td>1</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/mapping.py#L 98%"> 98%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/utils.py">utils.py</a></td><td>58</td><td>14</td><td>14</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/models/utils.py#L 76%"> 76%</a></td></tr><tr><td colspan="5"><b>data2rdf/modes</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/modes/__init__.py">__init__.py</a></td><td>4</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td colspan="5"><b>data2rdf/parsers</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/__init__.py">__init__.py</a></td><td>6</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/base.py">base.py</a></td><td>135</td><td>11</td><td>11</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/base.py#L 92%"> 92%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/csv.py">csv.py</a></td><td>168</td><td>20</td><td>20</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/csv.py#L 88%"> 88%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/excel.py">excel.py</a></td><td>183</td><td>17</td><td>17</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/excel.py#L 91%"> 91%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/json.py">json.py</a></td><td>216</td><td>37</td><td>37</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/json.py#L 83%"> 83%</a></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/utils.py">utils.py</a></td><td>90</td><td>10</td><td>10</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/parsers/utils.py#L 89%"> 89%</a></td></tr><tr><td colspan="5"><b>data2rdf/pipelines</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/pipelines/__init__.py">__init__.py</a></td><td>2</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/pipelines/main.py">main.py</a></td><td>82</td><td>9</td><td>9</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/pipelines/main.py#L 89%"> 89%</a></td></tr><tr><td colspan="5"><b>data2rdf/qudt</b></td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/qudt/__init__.py">__init__.py</a></td><td>0</td><td>0</td><td>100%</td><td>&nbsp;</td></tr><tr><td>&nbsp; &nbsp;<a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/qudt/utils.py">utils.py</a></td><td>42</td><td>12</td><td>12</td><td><a href="https://github.com/MI-FraunhoferIWM/data2rdf/blob/main/data2rdf/qudt/utils.py#L 71%"> 71%</a></td></tr><tr><td><b>TOTAL</b></td><td><b>1248</b></td><td><b>145</b></td><td><b>88%</b></td><td>&nbsp;</td></tr></tbody></table></details>
  <!-- Pytest Coverage Comment:End -->





  Either install the package from the pypi

  ```bash
  pip install data2rdf
  ```



  Install the package from the source code:
  ```bash
  git clone git@github.com:MI-FraunhoferIWM/data2rdf.git
  cd data2rdf
  pip install -e .
  ```



  Before running the unit tests, please install the needed packages:

  ```{bash}
  pip install data2rdf[tests]
  ```

  Afterwards, run the unittest with:

  ```{bash}
  pytest
  ```




  A server will start, generate the docs and listen for changes in the source files.
  This can be done by using docker or installing the development environment directly on the you machine. Next are installation guides for Docker and Linux OS.



  First, build the Docker image by running the following command:

  ```shell
  $ docker build -f docs.Dockerfile -t data2rdf-docs .
  ```

  Then, start the program by running:

  ```shell
  $ docker run -it --rm -v $PWD:/app -p 8000:8000 data2rdf-docs
  ```



  At an OS level (these commands work on Linux Debian):

  ```shell
  $ sudo apt install pandoc graphviz default-jre
  $ sudo apt-get install texlive-latex-recommended \
                         texlive-latex-extra \
                         texlive-fonts-recommended \
                         latexmk
  ```

  The python dependencies:

  ```shell
  $ pip install .[docs]
  ```

  Now you can start the server and render the docs:

  ```
  $ sphinx-autobuild docs/source docs/build/html
  ```

  The documentation will be available on [`http://127.0.0.1:8000`](http://127.0.0.1:8000).



  To generate a PDF of the documentation, simply run (from the root project folder):

  ```sh
  make -C docs latexpdf
  ```

  The generated PDF can be found under docs/build/latex/data2rdf_docs.pdf


pkgId: 5c8d51262ebfff30b7ab6f83c5376ede8bb724b43224a57892c75155771df601
name: python-data4co
arch: src
version: 0.0.1a19
epoch: 0
release: 1
summary: data4co provides convenient dataset generators for the combinatorial optimization problem
url: https://github.com/heatingma/Data4CO
rpm_license: Mulan PSL v2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data4co-0.0.1a19-1.src.rpm
checksum_type: sha256
description:
  [![PyPi version](https://badgen.net/pypi/v/data4co/)](https://pypi.org/pypi/data4co/)
  [![PyPI pyversions](https://img.shields.io/badge/dynamic/json?color=blue&label=python&query=info.requires_python&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fdata4co%2Fjson)](https://pypi.python.org/pypi/data4co/)
  [![Downloads](https://static.pepy.tech/badge/data4co)](https://pepy.tech/project/data4co)
  [![GitHub stars](https://img.shields.io/github/stars/heatingma/Data4CO.svg?style=social&label=Star&maxAge=8640)](https://GitHub.com/heatingma/Data4CO/stargazers/)

  A data generator tool for Combinatorial Optimization (CO) problems, enabling customizable, diverse, and scalable datasets for benchmarking optimization algorithms.



  **data**
  | Problem |     First      | Impl. | Second  | Impl. |      Third      | Impl. |
  |:-------:|:--------------:|:-----:|:-------:|:-----:|:---------------:|:-----:|
  |   TSP   | TSPLIB(Origin) |   ✔   | Uniform |   ✔   | Multi. Distros. |  📆   |
  |   MIS   |     SATLIB     |   ✔   |  KaMIS  |  📆   |       --        |  --   |

  **draw**
  | Problem |     problem      | Impl. |     solution     | Impl. |
  |:-------:|:----------------:|:-----:|:----------------:|:-----:|
  |   TSP   | draw_tsp_problem |   ✔  | draw_tsp_soluton |   ✔  |
  |   MIS   | draw_mis_problem |  ✔   | draw_mis_soluton |  ✔   |

  **evaluator**
  | Problem |     Base     | Impl. |      First      | Impl. | Second  | Impl. |      Third      | Impl. |
  |:-------:|:------------:|:-----:|:---------------:|:-----:|:-------:|:-----:|:---------------:|:-----:|
  |   TSP   | TSPEvaluator |   ✔   | TSPLIB(Origin)  |   ✔   | Uniform |   ✔   | Multi. Distros. |  📆   |
  |   MIS   | MISEvaluator |  📆   | SATLIBEvaluator |  📆   |   --    |  --   |       --        |  --   |

  **generator**
  | Problem |  Type1  | Impl. |  Type2   | Impl. |  Type3  | Impl. |  Type4   | Impl. |
  |:-------:|:-------:|:-----:|:--------:|:-----:|:-------:|:-----:|:--------:|:-----:|
  |   TSP   | uniform |   ✔   | gaussian |   ✔   | cluster |   ✔   | w/regret |   ✔   |
  |   MIS   |   ER    |   ✔   |    BA    |   ✔   |   HK    |   ✔   |    WS    |   ✔   |

  **solver**
  | Problem |   Base    | Impl. | First | Impl. |  Second  | Impl. |      Third      | Impl. |
  |:-------:|:---------:|:-----:|:-----:|:-----:|:--------:|:-----:|:---------------:|:-----:|
  |   TSP   | TSPSolver |   ✔   |  LKH  |   ✔   | Concorde |   ✔   | Concorde(Large) |   ✔   |
  |   MIS   | MISSolver |   ✔   | KaMIS |   ✔   |  Gurobi  |   ✔   |       --        |  --   |

  ✔: Supported; 📆: Planned for future versions (contributions welcomed!).



  **Github**

  Clone with the url https://github.com/heatingma/Data4CO.git , and the following packages are required, and shall be automatically installed by ``pip``:
  ```
  Python >= 3.8
  numpy>=1.24.4
  networkx==2.8.8
  tsplib95==0.7.1
  tqdm>=4.66.1
  pulp>=2.8.0,
  pandas>=2.0.0,
  scipy>=1.10.1
  requests>=2.31.0
  aiohttp>=3.9.3
  async_timeout>=4.0.3
  ```
  If you want to obtain complete data4co's functions, like drawing, the following packages need to be installed by ``pip``:
  ```
  matplotlib>=3.7.5
  ```

  **PyPI**

  It is very convenient to directly use the following commands
  ```
  pip install data4co
  ```



  ```python
  from data4co.solver import TSPLKHSolver

  tsp_lkh_solver = TSPLKHSolver(lkh_max_trials=500)
  tsp_lkh_solver.from_txt("path/to/read/file.txt")
  tsp_lkh_solver.solve()
  tsp_lkh_solver.evaluate()
  tsp_lkh_solver.to_txt("path/to/write/file.txt")
  ```



  ```python
  from data4co import TSPDataGenerator

  tsp_data_lkh = TSPDataGenerator(
      num_threads=8,
      nodes_num=50,
      data_type="uniform",
      solver="lkh",
      train_samples_num=16,
      val_samples_num=16,
      test_samples_num=16,
      save_path="path/to/save/"
  )

  tsp_data_lkh.generate()
  ```



  **test lkh**
  ```python
  >>> from data4co.evaluate import TSPLIBOriginEvaluator
  >>> from data4co.solver import TSPLKHSolver

  >>> lkh_solver = TSPLKHSolver(scale=1)
  >>> eva = TSPLIBOriginEvaluator()
  >>> eva.evaluate(lkh_solver, norm="EUC_2D")
             solved_costs       gt_costs          gaps
  att48      33523.708507   33523.708507  0.000000e+00
  eil51        429.983312     429.983312  0.000000e+00
  berlin52    7544.365902    7544.365902  3.616585e-14
  st70         678.557469     678.597452 -5.892021e-03
  eil76        545.229738     545.387552 -2.893612e-02
  pr76      108159.438274  108159.438274 -1.345413e-14
  kroA100    21285.443182   21285.443182  0.000000e+00
  kroC100    20750.762504   20750.762504  0.000000e+00
  kroD100    21294.290821   21294.290821  3.416858e-14
  rd100       7910.396210    7910.396210  0.000000e+00
  eil101       642.856874     642.309536  8.521414e-02
  lin105     14382.995933   14382.995933  0.000000e+00
  ch130       6110.900592    6110.860950  6.487238e-04
  ch150       6530.902722    6532.280933 -2.109847e-02
  tsp225      3859.000000    3859.000000  0.000000e+00
  a280        2588.301213    2586.769648  5.920765e-02
  pr1002    260277.189980  259066.663053  4.672646e-01
  pr2392    384469.093320  378062.826191  1.694498e+00
  AVG        50054.634253   49631.448887  1.250504e-01

  >>> eva.evaluate(lkh_solver, norm="GEO")
             solved_costs  gt_costs      gaps
  ulysses16        6859.0    6859.0  0.000000
  ulysses22        7013.0    7013.0  0.000000
  gr96            55209.0   55209.0  0.000000
  gr202           40160.0   40160.0  0.000000
  gr666          295012.0  294358.0  0.222178
  AVG             80850.6   80719.8  0.044436
  ```

  **test concorde**
  ```python
  >>> from data4co.evaluate import TSPLIBOriginEvaluator
  >>> from data4co.solver import TSPConcordeSolver

  >>> eva = TSPLIBOriginEvaluator()
  >>> con_solver = TSPConcordeSolver(scale=1)
  >>> eva.evaluate(con_solver, norm="EUC_2D")
             solved_costs       gt_costs          gaps
  att48      33523.708507   33523.708507  2.170392e-14
  eil51        429.117939     429.983312 -2.012573e-01
  berlin52    7544.365902    7544.365902  0.000000e+00
  st70         678.583751     678.597452 -2.019036e-03
  eil76        544.652026     545.387552 -1.348631e-01
  pr76      108159.438274  108159.438274 -1.345413e-14
  kroA100    21285.443182   21285.443182 -1.709139e-14
  kroC100    20750.762504   20750.762504  0.000000e+00
  kroD100    21294.290821   21294.290821  3.416858e-14
  rd100       7910.396210    7910.396210  0.000000e+00
  eil101       641.690973     642.309536 -9.630290e-02
  lin105     14382.995933   14382.995933  0.000000e+00
  ch130       6110.739012    6110.860950 -1.995428e-03
  ch150       6532.280933    6532.280933  0.000000e+00
  tsp225      3859.000000    3859.000000  0.000000e+00
  a280        2587.930486    2586.769648  4.487600e-02
  pr1002    259066.663053  259066.663053 -1.123411e-14
  pr2392    378062.826191  378062.826191  0.000000e+00
  AVG        49631.382539   49631.448887 -2.175343e-02

  >>> eva.evaluate(con_solver, norm="GEO")
             solved_costs  gt_costs  gaps
  ulysses16        6859.0    6859.0   0.0
  ulysses22        7013.0    7013.0   0.0
  gr96            55209.0   55209.0   0.0
  gr202           40160.0   40160.0   0.0
  gr666          294358.0  294358.0   0.0
  AVG             80719.8   80719.8   0.0
  ```



  **TSP**
  ```python
  from data4co.solver import TSPConcordeSolver
  from data4co.draw.tsp import draw_tsp_solution, draw_tsp_problem


  solver = TSPConcordeSolver(scale=1)
  solver.from_tsp("docs/kroA150.tsp")
  solver.solve(norm="EUC_2D")


  draw_tsp_problem(
      save_path="docs/kroA150_problem.png",
      points=solver.ori_points,
  )
  draw_tsp_solution(
      save_path="docs/kroA150_solution.png",
      points=solver.ori_points,
      tours=solver.tours
  )
  ```
  <details>
  <summary>Click to view the drawing results</summary>
  <img src="docs/kroA150_problem.png" width="35%" alt="" />
  <img src="docs/kroA150_solution.png" width="35%" alt="" />
  </details>

  **MIS**
  ```python
  from data4co.solver import KaMISSolver
  from data4co import draw_mis_problem, draw_mis_solution


  mis_solver = KaMISSolver()
  mis_solver.solve(src="docs/mis_example")


  draw_mis_problem(
      save_path="docs/mis_problem.png",
      ckle_path="docs/mis_example/mis_example.gpickle"
  )
  draw_mis_solution(
      save_path="docs/mis_solution.png",
      gpickle_path="docs/mis_example/mis_example.gpickle",
      result_path="docs/mis_example/solve/mis_example_unweighted.result"
  )
  ```
  <details>
  <summary>Click to view the drawing results</summary>
  <img src="docs/mis_problem.png" width="35%" alt="" />
  <img src="docs/mis_solution.png" width="35%" alt="" />
  </details>


pkgId: 58fe92bf4df64446c13e580871ed6e90c9a12f7f1e8bf3ebced5389a24231f25
name: python-data_check
arch: src
version: 0.19.0
epoch: 0
release: 1
summary: simple data validation
url: https://andrjas.github.io/data_check/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-data_check-0.19.0-1.src.rpm
checksum_type: sha256
description:
  data_check is a simple data validation tool. In its most basic form it will execute SQL queries and compare the results against CSV or Excel files. But there are more advanced features:



  * [CSV checks](https://andrjas.github.io/data_check/csv_checks/): compare SQL queries against CSV files
  * Excel support: Use Excel (xlsx) instead of CSV
  * multiple environments (databases) in the configuration file
  * [populate tables](https://andrjas.github.io/data_check/loading_data/) from CSV or Excel files
  * [execute any SQL files on a database](https://andrjas.github.io/data_check/sql/)
  * more complex [pipelines](https://andrjas.github.io/data_check/pipelines/)
  * run any script/command (via pipelines)
  * simplified checks for [empty datasets](https://andrjas.github.io/data_check/csv_checks/#empty-dataset-checks) and [full table comparison](https://andrjas.github.io/data_check/csv_checks/#full-table-checks)
  * [lookups](https://andrjas.github.io/data_check/csv_checks/#lookups) to reuse the same data in multiple queries
  * [test data generation](https://andrjas.github.io/data_check/test_data/)



  data_check is tested with these databases:

  - PostgreSQL
  - MySQL
  - SQLite
  - Oracle
  - Microsoft SQL Server

  Partially supported:

  - DuckDB
  - Databricks

  Other databases supported by [SQLAlchemy](https://docs.sqlalchemy.org/en/20/dialects/) might also work.



  You need Python 3.9 or above to run data_check. The easiest way to install data_check is via [pipx](https://github.com/pipxproject/pipx):

  `pipx install data-check`

  The data_check Git repository is also a sample data_check project. Clone the repository, switch to the folder and run data_check:

  ```
  git clone git@github.com:andrjas/data_check.git
  cd data_check/example
  data_check
  ```

  This will run the tests in the _checks_ folder using the default connection as set in data_check.yml.

  See the [documentation](https://andrjas.github.io/data_check) how to install data_check in different environments with additional database drivers and other usages of data_check.



  data_check has a simple layout for projects: a single configuration file and a folder with the test files. You can also organize the test files in subfolders.

      data_check.yml    # The configuration file
      checks/           # Default folder for data tests
          some_test.sql # SQL file with the query to run against the database
          some_test.csv # CSV file with the expected result
          subfolder/    # Tests can be nested in subfolders



  This is the default mode when running data_check. data_check expects a SQL file and a CSV file. The SQL file will be executed against the database and the result is compared with the CSV file. If they match, the test is passed, otherwise it fails.



  If data_check finds a file named _data\_check\_pipeline.yml_ in a folder, it will treat this folder as a pipeline check. Instead of running [CSV checks](#csv-checks) it will execute the steps in the YAML file.

  Example project with a pipeline:

      data_check.yml
      checks/
          some_test.sql                # this test will run in parallel to the pipeline test
          some_test.csv
          sample_pipeline/
              data_check_pipeline.yml  # configuration for the pipeline
              data/
                  my_schema.some_table.csv       # data for a table
              data2/
                  some_data.csv        # other data
              some_checks/             # folder with CSV checks
                  check1.sql
                  check1.csl
                  ...
              run_this.sql             # a SQL file that will be executed
              cleanup.sql
          other_pipeline/              # you can have multiple pipelines that will run in parallel
              data_check_pipeline.yml
              ...

  The file _sample\_pipeline/data\_check\_pipeline.yml_ can look like this:

  ```yaml
  steps:
      
      - load: data
      
      - sql: run_this.sql
      
      - load:
          file: data2/some_data.csv
          table: my_schema.other_table
          mode: append
      
      - cmd: "python3 /path/to/my_pipeline.py --connection {{CONNECTION}}"
      
      - check: some_checks
  ```

  Pipeline checks and simple CSV checks can coexist in a project.



  See the [documentation](https://andrjas.github.io/data_check) how to setup data_check, how to create a new project and more options.



  [MIT](LICENSE)


pkgId: 7039ff7c0ead60fbbfb337a584baee71fed123ce9e647d9c7183aec690c6f695
name: python-dataauto
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: An open-source tool for automating data analysis tasks.
url: https://github.com/r4mp4g3r/dataauto
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dataauto-1.0.3-1.src.rpm
checksum_type: sha256
description:
  **DataAuto** is an open-source tool designed to automate common data analysis tasks. Whether you're a beginner or a seasoned data scientist, DataAuto simplifies the process of loading, summarizing, visualizing your data, training machine learning models, generating reports, and much more.




  - **Load Data:** Easily load data from CSV, JSON, Excel files, or SQL databases.
  - **Save Data:** Save processed data to various formats or export to SQL databases.


  - **Handle Missing Values:** Fill missing data using mean, median, mode, or constant values.
  - **Remove Outliers:** Detect and remove outliers using IQR or Z-score methods.
  - **Scale Data:** Normalize or standardize numerical features using Min-Max or Standard scaling.


  - **Static Plots:** Generate histograms, scatter plots, box plots, heatmaps, and line charts using Matplotlib and Seaborn.
  - **Interactive Plots:** Create interactive visualizations with Plotly and Bokeh.
  - **Dashboards:** Launch interactive dashboards using Streamlit for real-time data exploration.


  - **Summary Statistics:** Quickly obtain descriptive statistics of your dataset.
  - **Automated Reports:** Generate comprehensive PDF reports summarizing your data analysis.


  - **Model Training:** Train machine learning models (regression and classification) with ease.
  - **Model Evaluation:** Evaluate model performance with detailed reports.
  - **Hyperparameter Tuning:** Optimize model parameters using Hyperopt.


  - **Task Scheduling:** Automate recurring data analysis tasks using APScheduler or Celery.
  - **CI/CD Integration:** Ensure code quality and automate deployments with GitHub Actions.


  - **Cloud Services:** Interact with AWS and Google Cloud services for scalable data storage and processing.
  - **Communication Platforms:** Send notifications and alerts via Slack or Microsoft Teams upon task completion or failures.


  - **Automated Testing:** Maintain code reliability with pytest, unittest, and coverage tools.
  - **Code Quality:** Enforce coding standards using flake8, pylint, and black.


  - **Comprehensive Docs:** Access detailed documentation, tutorials, and API references.
  - **Community Support:** Engage with other users and contributors through GitHub Discussions and dedicated Slack/Discord channels.


  - **Dynamic Filters:** Apply complex filters to your datasets using multiple conditions and logical operators.
  - **User-Friendly Interface:** Intuitive commands for specifying filter criteria without deep technical knowledge.



  **DataAuto** can be installed via `pip`. Ensure you have Python 3.8 or higher installed.

  ```bash
  pip install dataauto==1.0.3
  ```
  Alternatively, you can install directly from the GitHub repository:
  ```bash
  pip install git+https://github.com/r4mp4g3r/dataauto.git@v1.0.3
  ```


  1. Load Data

  Load a CSV file:
  ```bash
  dataauto load path/to/data.csv --format csv
  ```

  Load data from a PostgreSQL database:
  ```bash
  dataauto load --format sql --db-type postgresql --host localhost --port 5432 --dbname mydb --user myuser --password mypass --query "SELECT * FROM mytable"
  ```

  2. Summarize data

  Generate summary statistics:
  ```bash
  dataauto summarize path/to/data.csv
  ```

  3. Plot Data

  Generate a histogram:
  ```bash
  dataauto plot path/to/data.csv --plot-type histogram --column Age --output-dir plots
  ```

  Generate an interactive scatter plot:
  ```bash
  dataauto plot path/to/data.csv --plot-type scatter --x Age --y Salary --output-dir plots --interactive
  ```

  4. Train a Machine Learning Model

  Train a classifier:
  ```bash
  dataauto train path/to/data.csv --target TargetColumn --model-type classifier --output-model model.joblib --output-report report.txt
  ```

  5. Generate a Report

  Create a PDF report:
  ```bash
  dataauto report path/to/data.csv --output-report analysis_report.pdf
  ```

  6. Launch Dashboard

  Start the interactive dashboard:
  ```bash
  dataauto dashboard
  ```

  7. Schedule a Task

  Schedule a daily data load:
  ```bash
  dataauto schedule --cron "0 0 * * *" dataauto load path/to/data.csv --format csv
  ```



  Detailed usage examples can be found in the Examples directory. (In Progress)



  Check out our [ROADMAP.md](https://github.com/r4mp4g3r/dataauto/blob/main/ROADMAP.md) for upcoming features and improvements.



  We welcome contributions! Please see our CONTRIBUTING.md for guidelines.



  Please adhere to our CODE_OF_CONDUCT.md when interacting with the community.



  This project is licensed under the MIT License.



  	•	Pandas
  	•	Click
  	•	Seaborn
  	•	Matplotlib
  	•	Plotly
  	•	Streamlit
  	•	Scikit-learn
  	•	APScheduler
  	•	Celery
  	•	FPDF
  	•	Sphinx
  	•	MkDocs
  	•   Joblib


pkgId: 1a61cd2521759056d7e061eddc01cd1b3944275c0b6632605a8ac942e280deb1
name: python-databallpy
arch: src
version: 0.5.2
epoch: 0
release: 1
url: https://pypi.org/project/databallpy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databallpy-0.5.2-1.src.rpm
checksum_type: sha256
summary:
  A package for loading, preprocessing, vizualising and synchronizing soccere event and tracking data.

description:
  <div align="center">
    <img src="https://github.com/Alek050/databallpy/assets/49450063/56100e87-c680-4dc1-82e5-4aa8fdbc8a34" alt="Logo">
  </div>

  [version-image]: https://img.shields.io/pypi/v/databallpy?color=006666
  [version-url]: https://pypi.org/project/databallpy/
  [python-image]: https://img.shields.io/pypi/pyversions/databallpy?color=006666
  [python-url]: https://pypi.org/project/databallpy/
  [docs-image]: https://readthedocs.org/projects/databallpy/badge/?version=latest
  [docs-url]: https://databallpy.readthedocs.io/en/latest/?badge=latest
  [cicd-image]: https://github.com/Alek050/databallpy/actions/workflows/linters_and_tests.yml/badge.svg
  [cicd-url]: https://github.com/Alek050/databallpy/actions/workflows/linters_and_tests.yml
  [codecov-image]: https://codecov.io/gh/Alek050/databallpy/branch/develop/graph/badge.svg?token=MBI3380I0H
  [codecov-url]: https://codecov.io/gh/Alek050/databallpy

  [filter-data-url]: https://databallpy.readthedocs.io/en/latest/getting_started/preprocessing_options.html#filtering-data
  [velocity-acc-url]: https://databallpy.readthedocs.io/en/latest/getting_started/preprocessing_options.html#adding-velocity-and-acceleration
  [synchronisation-url]: https://databallpy.readthedocs.io/en/latest/getting_started/synchronisation_page.html
  [covered-distance-url]: https://databallpy.readthedocs.io/en/latest/features/covered_distance_page.html
  [pressure-url]: https://databallpy.readthedocs.io/en/latest/features/pressure_page.html
  [team-possession-url]: https://databallpy.readthedocs.io/en/latest/features/team_and_player_possession.html#team-possession
  [individual_possession-url]: https://databallpy.readthedocs.io/en/latest/features/team_and_player_possession.html#individual-player-possession-vidal-codina-et-al-2022
  [Expected-Goals-url]: https://databallpy.readthedocs.io/en/latest/features/simple_xG_models.html
  [Expected-Threat-url]: https://databallpy.readthedocs.io/en/latest/features/xT_models.html
  [Voronoi-url]: https://databallpy.readthedocs.io/en/latest/features/space_occupation.html#voronoi-model
  [Guassian-space-occupation-url]: https://databallpy.readthedocs.io/en/latest/features/space_occupation.html#gaussian-model-fernandez-born-2018
  [visualizations-url]: https://databallpy.readthedocs.io/en/latest/getting_started/visualizations_page.html

  [floodlight-url]:https://github.com/floodlight-sports/floodlight
  [kloppy-url]:https://github.com/PySport/kloppy
  [soccer-sync-url]: https://kwiatkowski.io/sync.soccer
  [example-url]: https://databallpy.readthedocs.io/en/latest/example.html
  [getting-started-url]: https://databallpy.readthedocs.io/en/latest/getting_started/installation_page.html

  [![Latest Version][version-image]][version-url]
  [![Python Version][python-image]][python-url]
  [![Documentation Status][docs-image]][docs-url]
  [![CI/CD Status][cicd-image]][cicd-url]
  [![Codecov][codecov-image]][codecov-url]



  A package for loading, synchronizing, and analyzing your soccer event- and tracking data.

  This package is developed to create a standardized way to analyse soccer matches using both event- and tracking data. Other packages, like [kloppy][kloppy-url] and [floodlight][floodlight-url], already standardize the import of data sources. The current package goes a step further in combining different data streams from the same match. In this case, the `Match` object combines information from the event and tracking data. The main current feature is the smart synchronization of the tracking and event data. We utilize the Needleman-Wunch algorithm, inspired by [this article][soccer-sync-url], to align the tracking and even data, while ensuring the order of the events, something that is not done when only using (different) cost functions.



  Although reading in and synchronising data is already very helpfull to get started with your analysis, it's only the first step. Even after this first step, getting your first 'simple' metrics out of the data might be more difficult than anticipated. Therefore, the primary end goal for this package is to create a space where (scientific) soccer metrics are implemented and can be used in a few lines. We even plan to go further and show clear notebooks (to combine text and code) with visualizations for all the features we implement. This way, you will not only get easy access to the features/metrics, but also understand exactly how it is calculated. We hope this will inspire others (both developers and scientist) to further improve the current features, and come up with valuable new ones. If you are interested in some of the features we implemented, see our [official documentation][docs-url].



  - Added `match.get_column_ids` with filters for team, player positions and minimal minutes played filters.
  - Added parser for DFL/Sportec Solutions event data
  - Added parser for Tracab xml format, used by DFL and Sportec solutions
  - Added integration for open data from DFL (open sourced by Bassek et al.)


  - From now on, `match.home_players_column_ids()` and `match.away_players_column_ids()` are depreciated and will be removed in V0.7.0. Please use `match.get_column_ids()` in future version.
  - `get_open_match()` will now, by default, load in match `J03WMX` (1. FC Köln vs. FC Bayern München) instead of the anonimysed match from Metrica. To load in the metrica match, please parse `provider="metrica"` in the key word arguments.



  ```bash
  $ pip install databallpy
  ```



  The package is centered around the `Match` object. A `Match` has tracking data, event data metadata about the match.
  For a more elaborate example, see the [Getting Started][getting-started-url].

  ```python
  from databallpy import get_match, get_open_match

  match = get_match(
    tracking_data_loc="../data/tracking_data.dat",
    tracking_metadata_loc="../data/tracking_metadata.xml",
    tracking_data_provider="tracab"
    event_data_loc="../data/event_data_f24.xml",
    event_metadata_loc="../data/event_metadata_f7.xml",
    event_data_provider="opta",
  )


  match = get_open_match()
  ```

  > [!note]
  > The current supported tracking data providers are:
  > - Tracab (including Sportec Solutions from the DFL)
  > - Metrica
  > - Inmotio
  >
  > The accepted variables for the `tracking_data_provider` are `["tracab", "metrica", "inmotio", "dfl", "sportec"]`
  >
  > The current supported event data provider are:
  > - Opta
  > - Metrica
  > - Instat
  > - SciSports
  > - Sportec Solutions (from the DFL)
  >
  > The accepted variables for the `event_data_provider` are `["opta", "metrica", "instat", "scisports", "dfl", "sportec"]`
  >
  > If you wish to use a different provider that is not listed here, please open an issue [here](https://github.com/Alek050/databallpy/issues)

  See [the documentation][docs-url] of the `Match` object and the [example usage][example-url] for more options. Note that this package is developed to combine event and tracking data, for now both datastreams are necessary to create a `Match` object.





  - [Data Filtering][filter-data-url]: Filter the data based on the quality of the tracking data.
  - [Adding velocity and Acceleration][velocity-acc-url]: Add velocity and acceleration to the tracking data.




  See our elaborate [synchronisation page][synchronisation-url] in the documentation for more information!

  Tracking and event data is often poorly synchronized. For instance, when taking the event data of Opta and tracking data of Tracab, you can sync the fist frame with the kick-off pass. Now you can sync the other events with the tracking data based on the time difference between the event and the kick off pass. If you do this, how get something like this:

  <video width="640" height="480" controls>
    <source src="https://raw.githubusercontent.com/Alek050/databallpy/main/docs/example_data/not_synced.mp4" type="video/mp4">
    Your browser does not support the video tag.
  </video>

  https://user-images.githubusercontent.com/49450063/224564808-fa71735f-5510-464d-8499-9044227a02e8.mp4


  As you can see, the timing (and placing) of the events do not correspond good with the tracking data locations, especially when events follow up quickly or around shots. Using the methodology of [this][soccer-sync-url] article, this package is able to synchronize tracking and event data using the Needleman-Wunsch algorithm.

  After running the following command, the events are better synchronized to the tracking data:

  ```batch
  $ match.synchronise_tracking_and_event_data()
  ```

  <video width="640" height="480" controls>
    <source src="https://raw.githubusercontent.com/Alek050/databallpy/main/docs/example_data/synced.mp4" type="video/mp4">
    Your browser does not support the video tag.
  </video>


  https://user-images.githubusercontent.com/49450063/224564913-4091faf7-f6ef-4429-b132-7f93ce5e1d91.mp4

  For a more elaborate example of how we synchronize the tracking and event data, see the [Synchronisation Page][getting-started-url] in our [documentation][docs-url].



  DataBallPy offers a variety of visualizations to help you understand the data better. For example, you can visualize the tracking data with synchronised event as shown above. Also, you can visualize events and tracking data separately. For more information, see the [Visualizations Page][visualizations-url] in our [documentation][docs-url].



  - [Covered Distance][covered-distance-url]: Calculate the covered distance in different velocity and acceleration zones.
  - [Pressure][pressure-url]: Calculate the pressure any player in the match (Herold & Kempe, 2022).
  - [Team Possession][team-possession-url]: Calculate the team possession based on the synchronised event data.
  - [Individual Player Possession][individual_possession-url]: Calculate the individual player possession based on the tracking data (Vidal-Codina et al., 2022).
  - [Simple Expected Goals (xG) model][Expected-Goals-url]: Calculate the simple expected goals model.
  - [Expected Threat model][Expected-Threat-url]: Calculate the expected threat model from Karun Singh to on ball events.
  - [Voronoi Model][Voronoi-url]: Calculate the Voronoi space occupation based on the tracking data.
  - [Gaussian Model][Guassian-space-occupation-url]: Calculate the Gaussian space occupation based on the tracking data (Fernandez & Born, 2018).



  The official documentation can be found [here][docs-url].



  For now we limited providers. We are planning on adding more providers later on.

  Event data providers:
  - Opta
  - Metrica
  - Instat
  - SciSports
  - Sportec Solutions (for the DFL)

  Tracking data providers:
  - Tracab (including Sportec Solutions format from the DFL)
  - Metrica
  - Inmotio



  Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.



  - [Alek050](https://github.com/Alek050/)



  - [DaanGro](https://github.com/DaanGro/)
  - [rdghe](https://github.com/rdghe/)
  - [swopper050](https://github.com/Swopper050)
  - [maritsloots](https://github.com/maritsloots)



  `databallpy` was created by Alexander Oonk & Daan Grob. It is licensed under the terms of the MIT license.



  Although we think this package helps when starting to analyse soccer data, other packages may be better suited for your specific needs. Make sure to check out the following packages as well:
  - [kloppy][kloppy-url]
  - [floodlight][floodlight-url]
  - [codeball](https://github.com/metrica-sports/codeball)
  - [socceraction](https://github.com/ML-KULeuven/socceraction)

  And for a more specific toturials on how to get started with soccer data"
  - [Friends of Tracking](https://github.com/Friends-of-Tracking-Data-FoTD)


pkgId: 31a356df360eba0d9925f78b661034749057cfd2bce420343cd7c20bb738c2f6
name: python-databand
arch: src
version: 1.0.25.2
epoch: 0
release: 1
summary: Machine Learning Orchestration
url: https://github.com/databand-ai/dbnd
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databand-1.0.25.2-1.src.rpm
checksum_type: sha256
description:
  [![pipeline status](https://gitlab.com/databand-ai/dbnd/badges/master/pipeline.svg)](https://gitlab.com/databand-ai/dbnd/pipelines)

  ![PyPI - Downloads](https://img.shields.io/pypi/dm/dbnd) ![PyPI](https://img.shields.io/pypi/v/dbnd)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dbnd) ![PyPI - License](https://img.shields.io/pypi/l/dbnd)
  ![Code style: ](https://img.shields.io/badge/code%20style-black-000000.svg)



  DBND an open source framework for building and tracking data pipelines. DBND is used for processes ranging from data ingestion, preparation, machine learning model training and production.

  DBND includes a Python library, set of APIs, and CLI that enables you to collect metadata from your workflows, create a system of record for runs, and easily orchestrate complex processes.

  DBND simplifies the process of building and running data pipelines
  from dbnd import task

  ```python
  from dbnd import task

  @task
  def say_hello(name: str = "databand.ai") -> str:
      value = "Hello %s!" % name
      return value
  ```

  And makes it easy to track your critical pipeline metadata

  ```python
  from dbnd import log_metric, log_dataframe

  log_dataframe("my_dataset", my_dataset)
  log_metric("r2", r2)
  ```



  See our [documentation](https://www.ibm.com/docs/en/dobd) with examples and quickstart guides to get up and running with DBND.



  For using DBND, we recommend that you work with a virtual environment like [Virtualenv](https://virtualenv.pypa.io/en/latest/) or [Conda](https://docs.conda.io/en/latest/). Update to the latest and greatest:

  ```shell script
  pip install dbnd
  ```

  If you would like access to our latest features, or have any questions, feedback, or contributions we would love to here from you! Get in touch through contact@databand.ai


pkgId: 9178f59614f50a7f024cfe8cc62839db76581e37764500f24764fe1c7b270991
name: python-databank
arch: src
version: 0.8.0
epoch: 0
release: 1
url: https://pypi.org/project/databank/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databank-0.8.0-1.src.rpm
checksum_type: sha256
summary:
  Databank is an easy-to-use Python library for making raw SQL queries in a multi-threaded environment.

description:
  [![PyPI](https://img.shields.io/pypi/v/databank.svg)](https://pypi.org/project/databank) ![GitHub Actions](https://github.com/snapADDY/databank/actions/workflows/main.yml/badge.svg)

  Databank is an easy-to-use Python library for making raw SQL queries in a multi-threaded environment.

  No ORM, no frills. Only raw SQL queries and parameter binding. Thread-safe. Built on top of [SQLAlchemy](https://www.sqlalchemy.org/).

  [![IBM System/360 Model 91](https://live.staticflickr.com/7328/9169294489_ba900907f1_b.jpg)](https://www.flickr.com/photos/mratzloff/9169294489/)

  (The photo was taken by [Matthew Ratzloff](https://www.flickr.com/photos/mratzloff/) and is licensed under CC BY-NC-ND 2.0.)


  You can install the latest stable version from [PyPI](https://pypi.org/project/databank/):

  ```
  $ pip install databank
  ```

  **Adapters not included.** Install e.g. `psycopg2` for PostgreSQL:

  ```
  $ pip install psycopg2
  ```



  Connect to the database of your choice:

  ```python
  >>> from databank import Database
  >>> db = Database("postgresql://user:password@localhost/db", pool_size=2)
  ```

  The keyword arguments are passed directly to SQLAlchemy's `create_engine()` function. Depending on the database you connect to, you have options like the size of connection pools.

  > If you are using `databank` in a multi-threaded environment (e.g. in a web application), make sure the pool size is at least the number of worker threads.

  Let's create a simple table:

  ```python
  >>> db.execute("CREATE TABLE beatles (id SERIAL PRIMARY KEY, member TEXT NOT NULL);")
  ```

  You can insert multiple rows at once:

  ```python
  >>> params = [
  ...     {"id": 0, "member": "John"},
  ...     {"id": 1, "member": "Paul"},
  ...     {"id": 2, "member": "George"},
  ...     {"id": 3, "member": "Ringo"}
  ... ]
  >>> db.execute_many("INSERT INTO beatles (id, member) VALUES (:id, :member);", params)
  ```

  Fetch a single row:

  ```python
  >>> db.fetch_one("SELECT * FROM beatles;")
  {'id': 0, 'member': 'John'}
  ```

  But you can also fetch `n` rows:

  ```python
  >>> db.fetch_many("SELECT * FROM beatles;", n=2)
  [{'id': 0, 'member': 'John'}, {'id': 1, 'member': 'Paul'}]
  ```

  Or all rows:

  ```python
  >>> db.fetch_all("SELECT * FROM beatles;")
  [{'id': 0, 'member': 'John'},
   {'id': 1, 'member': 'Paul'},
   {'id': 2, 'member': 'George'},
   {'id': 3, 'member': 'Ringo'}]
  ```

  If you are using PostgreSQL with `jsonb` columns, you can use a helper function to serialize the parameter values:

  ```python
  >>> from databank.utils import serialize_params
  >>> serialize_params({"member": "Ringo", "song": ["Don't Pass Me By", "Octopus's Garden"]})
  {'member': 'Ringo', 'song': '["Don\'t Pass Me By", "Octopus\'s Garden"]'}
  ```



  For both `execute()` and `execute_many()` you can pass an `in_background` keyword argument (which is by default `False`). If set to `True`, the query will be executed in the background in another thread and the method will return immediately the `Thread` object (i.e. non-blocking). You can call `join()` on that object to wait for the query to finish or just do nothing and go on:

  ```python
  >>> db.execute("INSERT INTO beatles (id, member) VALUES (:id, :member);", {"id": 4, "member": "Klaus"}, in_background=True)
  <Thread(Thread-1 (_execute), started 140067398776512)>
  ```

  Beware that if you are using `in_background=True`, you have to make sure that the connection pool size is large enough to handle the number of concurrent queries and that your program is running long enough if you are not explicitly waiting for the thread to finish. Also note that this might lead to a range of other issues like locking, reduced performance or even deadlocks. You also might want to set an explicit timeout for queries by passing e.g. `{"options": "-c statement_timeout=60000"}` for PostgreSQL when initializing the `Database` object to kill all queries taking longer than 60 seconds.




  You can also organize SQL queries in an SQL file and load them into a `QueryCollection`:

  ```sql
  /* @name insert_data */
  INSERT INTO beatles (id, member) VALUES (:id, :member);

  /* @name select_all_data */
  SELECT * FROM beatles;
  ```

  > This idea is borrowed from [PgTyped](https://pgtyped.dev/docs/sql-file)

  A query _must_ have a header comment with the name of the query. If a query name is not unique, the last query with the same name will be used. You can parse that file and load the queries into a `QueryCollection`:

  ```python
  >>> from databank import QueryCollection
  >>> queries = QueryCollection.from_file("queries.sql")
  ```

  and access the queries like in a dictionary:

  ```python
  >>> queries["insert_data"]
  'INSERT INTO beatles (id, member) VALUES (:id, :member);'
  >>> queries["select_all_data"]
  'SELECT * FROM beatles;'
  ```


pkgId: e539819c801584b485c16eec62f48f48e8e6680a3e616594f22844af719c70ee
name: python-database-knotinfo
arch: src
version: 2024.12.1
epoch: 0
release: 1
summary: The KnotInfo and LinkInfo databases as lists of dictionaries
url: https://github.com/soehms/database_knotinfo
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-knotinfo-2024.12.1-1.src.rpm
checksum_type: sha256
description:
  This repository contains a snapshot of the complete content
  of the [KnotInfo](https://knotinfo.math.indiana.edu/) and
  [LinkInfo](https://linkinfo.sitehost.iu.edu/) databases.
  Each database is provided as a Python list of Python dictionaries.
  The data are from the corresponding Excel spreadsheets available
  on the KnotInfo and LinkInfo homepages on the date of release.

  Please note that the databases contain columns that are not visible on
  the web pages (see also the [Release Notes 2023.4.8](https://github.com/soehms/database_knotinfo/releases/tag/2022.4.8)).
  The validity of the information in such columns cannot be guaranteed.
  Also, there are plans to remove them in the future.

  This repository was created as a part of the
  [SageMath](https://www.sagemath.org/) interface to these databases
  (see the [corresponding section](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knotinfo.html)
  of the SageMath reference manual or [this tutorial](tutorials/sage_knotinfo_interface_tutorial.ipynb))
  but can also be used independently.

  In Python, it can be used as follows:

  ```python
  >>> from database_knotinfo import link_list
  >>> k = link_list()
  >>> len(k)
  2979
  >>> names_k = k[0]
  >>> type(names_k)
  <type 'dict'>
  >>> names_k['braid_index']
  'Braid Index'
  >>> k2 = k[2]
  >>> k2['name']
  '3_1'
  >>> k2['braid_index']
  '2'
  >>> k2['homfly_polynomial']
  '(2*v^2-v^4)+(v^2)*z^2'

  >>> l = link_list(proper_links=True)
  >>> len(l)
  4189
  >>> names_l = l[0]
  >>> type(names_l)
  <type 'dict'>
  >>> names_l['braid_notation']
  'Braid Notation'
  >>> l2 = l[2]
  >>> l2['name']
  'L2a1{1}'
  >>> l2['homflypt_polynomial']
  'v/z-v^3/z + v*z'
  ```

  To build a new release, the `CSV` files can be upgraded with the
  `create_knotinfo_csv.py` script. A [cronjob](https://github.com/soehms/database_knotinfo/blob/main/.github/workflows/check_version_changed.yml)
  executes it on the first day of every month and creates a new
  release if differences are detected.





  ```bash
  pip install database_knotinfo
  ```

  or

  ```bash
  pip install database_knotinfo==2021.9.1
  ```

  if you want to install a former version.




  Since Release 9.4, the database can be installed in Sage by:

  ```bash
  sage -i database_knotinfo
  ```

  This will contain integration with the knot and link functionality of Sage.
  Sage 9.4 ships the PyPI release [0.7](https://pypi.org/project/database-knotinfo/0.7/)
  of the database. To use a more recent one you have to execute

  ```bash
  sage -package update database_knotinfo <version>
  ```

  before the installation command above, for example:

  ```bash
  sage -package update database_knotinfo 2021.9.1
  ```

  This procedure can be used to upgrade to the next version, as well. But note
  that there is a bug in 9.4 concerning such upgrades which will be fixed in
  SageMath 9.5 (see Trac ticket [#32099](https://trac.sagemath.org/ticket/32099)).
  A workaround for 9.4 can be perfomed in a Sage session as follows:

  ```
  sage: from sage.databases.knotinfo_db import KnotInfoDataBase
  sage: KnotInfoDataBase().reset_filecache()
  ```

  If you upgrade to a version of the database which is ahead of the version the
  SageMath release is build on, you should keep in mind, that the examples shown
  in the Sage reference manual may be outdated.

  In case the installation via `sage -i` is failing on your system you can try:

  ```bash
  sage -pip install database_knotinfo
  ```

  or

  ```bash
  sage -pip install database_knotinfo==0.7
  ```

  for the version compatible the the current Sage release.

  [![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/soehms/database_knotinfo)





  Version numbers are automatically generated every month if differences to the
  original databases are detected. They follow the scheme

  \<year\>.\<month\>.\<day\>



  If you note a divergence between this repository and the original data in case
  the current release is older than a month please create an issue about that.



  Many thanks to Chuck Livingston and Allison Moore for making the data
  available. For further acknowledgments see the corresponding homepages.


pkgId: 766ee6c238410a3222885fc6ececc30b05b406de7f8b90cb94307ad9fddaf806
name: python-database-sanitizer
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Sanitizes contents of a database.
url: https://github.com/andersinno/python-database-sanitizer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-sanitizer-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![pypi][pypi-image]][pypi-url]
  [![travis][travis-image]][travis-url]
  [![codecov][codecov-image]][codecov-url]

  [pypi-image]: https://badge.fury.io/py/database-sanitizer.svg
  [pypi-url]: https://pypi.org/project/database-sanitizer/
  [travis-image]: https://travis-ci.org/andersinno/python-database-sanitizer.svg?branch=master
  [travis-url]: https://travis-ci.org/andersinno/python-database-sanitizer
  [codecov-image]: https://codecov.io/gh/andersinno/python-database-sanitizer/branch/master/graph/badge.svg
  [codecov-url]: https://codecov.io/gh/andersinno/python-database-sanitizer

  `database-sanitizer` is a tool which retrieves an database dump from
  relational database and performs sanitation on the retrieved data
  according to rules defined in a configuration file. Currently the
  sanitation tool supports both [PostgreSQL] and [MySQL] databases.

  [PostgreSQL]: https://postgres.org
  [MySQL]: https://mysql.com



  `database-sanitizer` can be installed from [PyPI] with [pip] like this:

  ```bash
  $ pip install database-sanitizer
  ```

  If you are using MySQL, you need to install the package like this
  instead, so that additional requirements are included:

  ```bash
  $ pip install database-sanitizer[MySQL]
  ```

  [PyPI]: https://pypi.org
  [pip]: https://pip.pypa.io/en/stable/



  Once the package has been installed, `database-sanitizer` can be used
  like this:

  ```bash
  $ database-sanitizer <DATABASE-URL>
  ```

  Command line argument `DATABASE-URL` needs to be provided so the tool
  knows how to retrieve the dump from the database. With PostgreSQL, it
  would be something like this:

  ```bash
  $ database-sanitizer postgres://user:password@host/database
  ```

  However, unless an configuration file is provided, no sanitation will be
  performed on the retrieved database dump, which leads us to the next
  section which will be...



  Rules for the sanitation can be given in a configuration file written in
  [YAML]. Path to the configuration file is then given to the command line
  utility with `--config` argument (`-c` for shorthand) like this:

  [YAML]: http://yaml.org

  ```bash
  $ database-sanitizer -c config.yml postgres://user:password@host/database
  ```

  The configuration file uses following kind of syntax:

  ```YAML
  config:
    addons:
      - some.other.package
      - yet.another.package
    extra_parameters: # These parameters will be passed to the dump tool CLI
      mysqldump:
        - "--single-transaction" # Included by default
      pg_dump:
        - "--exclude-table=something"
  strategy:
    user:
      first_name: name.first_name
      last_name: name.last_name
      secret_key: string.empty
    access_log: skip_rows
  ```

  In the example configuration above, there are first listed two "addon
  packages", which are names of Python packages where the sanitizer will
  be looking for sanitizer functions. They are completely optional and can
  be omitted, in which case only sanitizer functions defined in package
  called `sanitizers` and built-in sanitizers will be used instead.

  It's also possible to define extra parameters to pass to the dump tool (
  `mysqldump` or `pg_dump`). By default, `mysqldump` will include the
  `--single-transaction` extra parameter. You can disable this by defining the
  extra parameters in the config file explicitly, e.g. with an empty array `[]`.

  The `strategy` portion of the configuration contains the actual
  sanitation rules. First you define name of the database table (in the
  example that would be `user`) followed by column names in that table
  which each one mapped to sanitation function name. The name of the
  sanitation function consists from two parts separated from each other by
  a dot: Python module name and name of the actual function, which will
  be prefixed with `sanitize_`, so `name.first_name` would be a function
  called `sanitize_first_name` in a file called `name.py`.

  Table content can be left out completely from the sanitized dump by
  setting table strategy to `skip_rows` (check `access_log` table in the
  example config). This will leave out all `INSERT INTO` (MySQL) or `COPY`
  (PostgreSQL) statements from the sanitized dump file. `CREATE TABLE`
  statements will not be removed.


pkgId: 1443f09cd09dc7e45005e0bae58d96113f70f968fc8c69d47913304a3c20a00a
name: python-database-setup
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Database setup utilities with configuration handling
url: https://pypi.org/project/database-setup/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-setup-0.0.5-1.src.rpm
checksum_type: sha256
description:
  `database_setup` is a Python package designed to streamline database configuration and initialization. It supports YAML-based configuration files, database connection pooling, and utility functions for database management.



  - Load database configurations from YAML files.
  - Create databases if they do not exist.
  - Execute schema and seed SQL files.
  - Insert default admin user with encrypted credentials.
  - Utilize connection pooling for optimized performance.



  Install the package via pip:

  ```bash
  pip3 install database_setup
  ```



  Import the Package

  ```
  from database_setup import setup_database
  ```


  Ensure your project directory contains a config/database.yml file with the following structure:

  ```yaml
  development:
    host: "localhost"
    port: 3306
    username: "root"
    password: "password"
    database: "example_db"
    autocommit: True
    blocking: True
    maxconnections: 5
  ```

  Ensure the config folder contains schema.sql and seed.sql files for database schema and initial data.

  Run the setup_database function:

  setup_database('/path/to/project')

  Replace /path/to/project with the absolute path to your project directory.

  Example Database Configuration File
  config/database.yml:

  ```yaml
  development:
    host: "localhost"
    port: 3306
    username: "root"
    password: "password"
    database: "example_db"
    autocommit: True
    blocking: True
    maxconnections: 5
  ```
  Example Schema File
  config/schema.sql:

  ```sql
  CREATE TABLE IF NOT EXISTS User (
      id INT AUTO_INCREMENT PRIMARY KEY,
      user_type VARCHAR(50),
      name VARCHAR(100),
      username VARCHAR(50) UNIQUE,
      email VARCHAR(100),
      mobile VARCHAR(15),
      password TEXT,
      user_access TINYINT
  );
  ```

  Example Seed File
  config/seed.sql:

  ```sql
  INSERT INTO User (user_type, name, username, email, mobile, password, user_access)
  VALUES ('admin', 'Default Admin', 'admin', 'info@yun.buzz', '8888888888', '<encrypted_password>', 1);
  ```



  This package depends on the following libraries:
  - pymysql
  - dbutils
  - PyYAML



  This package is proprietary software and is distributed under the terms of the Proprietary License. Unauthorized redistribution or modification is prohibited. See the LICENSE file for more information.


  For inquiries or support contact: Neudeep Technologies Pvt Ltd

  📧 neudeep.tech.pvt.ltd@gmail.com


pkgId: f26863dc8879998e452920228a4876cc03f97c3f5dda1e6e0791d7e03adebf0b
name: python-database-wrapper
arch: src
version: 0.1.40
epoch: 0
release: 1
summary: A Different Approach to Database Wrappers in Python
url: https://github.com/gintsmurans/py_database_wrapper
rpm_license: GNU General Public License v3.0 (GPL-3.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-wrapper-0.1.40-1.src.rpm
checksum_type: sha256
description:
  _Part of the `database_wrapper` package._

  This package is a base package for database wrappers. It is not intended to be used directly, but rather to be used via one of the database specific packages.


  See the README.md files in the database specific packages for more information.

  * [database_wrapper_pgsql](https://pypi.org/project/database_wrapper_pgsql/)
  * [database_wrapper_mysql](https://pypi.org/project/database_wrapper_mysql/)
  * [database_wrapper_mssql](https://pypi.org/project/database_wrapper_mssql/)
  * [database_wrapper_sqlite](https://pypi.org/project/database_wrapper_sqlite/)


pkgId: f3392f5821c594513fbea8905cf07d33f4d7b7e22a4f3c48bd20956eb5c274ce
name: python-database-wrapper-mssql
arch: src
version: 0.1.40
epoch: 0
release: 1
summary: database_wrapper for MSSQL database
url: https://github.com/gintsmurans/py_database_wrapper
rpm_license: GNU General Public License v3.0 (GPL-3.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-wrapper-mssql-0.1.40-1.src.rpm
checksum_type: sha256
description:
  _Part of the `database_wrapper` package._

  This python package is a database wrapper for [MSSQL](https://www.microsoft.com/en-us/sql-server/sql-server-downloads) database.



  ```bash
  pip install database_wrapper[mssql]
  ```



  ```python
  from database_wrapper_mssql import MSSQL, DBWrapperMSSQL

  db = MSSQL({
      "hostname": "localhost",
      "port": "1433",
      "username": "sa",
      "password": "your_password",
      "database": "master"
  })
  db.open()
  dbWrapper = DBWrapperMSSQL(db=db)


  aModel = MyModel()
  res = await dbWrapper.getByKey(
      aModel,
      "id",
      3005,
  )
  if res:
      print(f"getByKey: {res.toDict()}")
  else:
      print("No results")


  res = await dbWrapper.getAll(
      aModel,
      customQuery="""
          SELECT t1.*, t2.name AS other_name
          FROM my_table AS t1
          LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
      """
  )
  async for record in res:
      print(f"getAll: {record.toDict()}")
  else:
      print("No results")

  db.close()
  ```


pkgId: d9722097b600c4b912e436b5a78c636d85f6c424a35d5fa72df3ba43031ea837
name: python-database-wrapper-mssql
arch: src
version: 0.1.72
epoch: 0
release: 1
summary: database_wrapper for MSSQL database
url: https://github.com/gintsmurans/py_database_wrapper
rpm_license: GNU General Public License v3.0 (GPL-3.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-wrapper-mssql-0.1.72-1.src.rpm
checksum_type: sha256
description:
  _Part of the `database_wrapper` package._

  This python package is a database wrapper for [MSSQL](https://www.microsoft.com/en-us/sql-server/sql-server-downloads) database.



  ```bash
  pip install database_wrapper[mssql]
  ```



  ```python
  from database_wrapper_mssql import MSSQL, DBWrapperMSSQL

  db = MSSQL({
      "hostname": "localhost",
      "port": "1433",
      "username": "sa",
      "password": "your_password",
      "database": "master"
  })
  db.open()
  dbWrapper = DBWrapperMSSQL(dbCursor=db.cursor)


  aModel = MyModel()
  res = await dbWrapper.getByKey(
      aModel,
      "id",
      3005,
  )
  if res:
      print(f"getByKey: {res.toDict()}")
  else:
      print("No results")


  res = await dbWrapper.getAll(
      aModel,
      customQuery="""
          SELECT t1.*, t2.name AS other_name
          FROM my_table AS t1
          LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
      """
  )
  async for record in res:
      print(f"getAll: {record.toDict()}")
  else:
      print("No results")

  db.close()
  ```


pkgId: 2174ec0ca53264b767bdc9da35c712ebe808ec1cc3e08f6fa9c47341d18808a6
name: python-database-wrapper-mysql
arch: src
version: 0.1.40
epoch: 0
release: 1
summary: database_wrapper for MySQL database
url: https://github.com/gintsmurans/py_database_wrapper
rpm_license: GNU General Public License v3.0 (GPL-3.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-wrapper-mysql-0.1.40-1.src.rpm
checksum_type: sha256
description:
  _Part of the `database_wrapper` package._

  This python package is a database wrapper for [MySQL](https://www.mysql.com/) and [MariaDB](https://mariadb.org/) database.



  ```bash
  pip install database_wrapper[mysql]
  ```



  ```python
  from database_wrapper_mysql import MySQL, DBWrapperMySQL

  db = MySQL({
      "hostname": "localhost",
      "port": 3306,
      "username": "root",
      "password": "your_password",
      "database": "my_database"
  })
  db.open()
  dbWrapper = DBWrapperMySQL(db=db)


  aModel = MyModel()
  res = await dbWrapper.getByKey(
      aModel,
      "id",
      3005,
  )
  if res:
      print(f"getByKey: {res.toDict()}")
  else:
      print("No results")


  res = await dbWrapper.getAll(
      aModel,
      customQuery="""
          SELECT t1.*, t2.name AS other_name
          FROM my_table AS t1
          LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
      """
  )
  async for record in res:
      print(f"getAll: {record.toDict()}")
  else:
      print("No results")

  db.close()
  ```


pkgId: f5eb685a5ab43dcf61b1647734c996fd0210295555f7ee41c0f07e16f3f2565b
name: python-database-wrapper-mysql
arch: src
version: 0.1.72
epoch: 0
release: 1
summary: database_wrapper for MySQL database
url: https://github.com/gintsmurans/py_database_wrapper
rpm_license: GNU General Public License v3.0 (GPL-3.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-wrapper-mysql-0.1.72-1.src.rpm
checksum_type: sha256
description:
  _Part of the `database_wrapper` package._

  This python package is a database wrapper for [MySQL](https://www.mysql.com/) and [MariaDB](https://mariadb.org/) database.



  ```bash
  pip install database_wrapper[mysql]
  ```



  ```python
  from database_wrapper_mysql import MySQL, DBWrapperMySQL

  db = MySQL({
      "hostname": "localhost",
      "port": 3306,
      "username": "root",
      "password": "your_password",
      "database": "my_database"
  })
  db.open()
  dbWrapper = DBWrapperMySQL(dbCursor=db.cursor)


  aModel = MyModel()
  res = await dbWrapper.getByKey(
      aModel,
      "id",
      3005,
  )
  if res:
      print(f"getByKey: {res.toDict()}")
  else:
      print("No results")


  res = await dbWrapper.getAll(
      aModel,
      customQuery="""
          SELECT t1.*, t2.name AS other_name
          FROM my_table AS t1
          LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
      """
  )
  async for record in res:
      print(f"getAll: {record.toDict()}")
  else:
      print("No results")

  db.close()
  ```


pkgId: 86eb710e0568827e03bf16a23b573aeb2843ce353c34ecfea5610deaf9e58860
name: python-database-wrapper-pgsql
arch: src
version: 0.1.40
epoch: 0
release: 1
summary: database_wrapper for PostgreSQL database
url: https://github.com/gintsmurans/py_database_wrapper
rpm_license: GNU General Public License v3.0 (GPL-3.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-wrapper-pgsql-0.1.40-1.src.rpm
checksum_type: sha256
description:
  _Part of the `database_wrapper` package._

  This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) database.



  ```bash
  pip install database_wrapper[pgsql]
  ```



  ```python
  from database_wrapper_pgsql import PgSQLWithPoolingAsync, DBWrapperPgSQLAsync

  db = PgSQLWithPoolingAsync({
      "hostname": "localhost",
      "port": 3306,
      "username": "root",
      "password": "your_password",
      "database": "my_database"
  })
  db.open()
  dbWrapper = DBWrapperPgSQLAsync(db=db)


  aModel = MyModel()
  res = await dbWrapper.getByKey(
      aModel,
      "id",
      3005,
  )
  if res:
      print(f"getByKey: {res.toDict()}")
  else:
      print("No results")


  res = await dbWrapper.getAll(
      aModel,
      customQuery="""
          SELECT t1.*, t2.name AS other_name
          FROM my_table AS t1
          LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
      """
  )
  async for record in res:
      print(f"getAll: {record.toDict()}")
  else:
      print("No results")

  db.close()
  ```


pkgId: 1456eaec5b48b8968178cfe9e8f844174767e77f253282241b33b664eec541f8
name: python-database-wrapper-pgsql
arch: src
version: 0.1.72
epoch: 0
release: 1
summary: database_wrapper for PostgreSQL database
url: https://github.com/gintsmurans/py_database_wrapper
rpm_license: GNU General Public License v3.0 (GPL-3.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-wrapper-pgsql-0.1.72-1.src.rpm
checksum_type: sha256
description:
  _Part of the `database_wrapper` package._

  This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) database.



  ```bash
  pip install database_wrapper[pgsql]
  ```



  ```python
  from database_wrapper_pgsql import PgSQLWithPoolingAsync, DBWrapperPgSQLAsync

  db = PgSQLWithPoolingAsync({
      "hostname": "localhost",
      "port": 3306,
      "username": "root",
      "password": "your_password",
      "database": "my_database"
  })
  await db.openPool()
  try:
      async with db as (dbConn, dbCursor):
          dbWrapper = DBWrapperPgSQLAsync(dbCursor=dbCursor)

          
          aModel = MyModel()
          res = await dbWrapper.getByKey(
              aModel,
              "id",
              3005,
          )
          if res:
              print(f"getByKey: {res.toDict()}")
          else:
              print("No results")

          
          res = await dbWrapper.getAll(
              aModel,
              customQuery="""
                  SELECT t1.*, t2.name AS other_name
                  FROM my_table AS t1
                  LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
              """
          )
          async for record in res:
              print(f"getAll: {record.toDict()}")
          else:
              print("No results")

  finally:
      await db.openPool()
  ```


pkgId: f4e0316b4d2bb7f251c6e794937dea367e4153ef831296c5d285be739d3844d8
name: python-database-wrapper-sqlite
arch: src
version: 0.1.40
epoch: 0
release: 1
summary: database_wrapper for PostgreSQL database
url: https://github.com/gintsmurans/py_database_wrapper
rpm_license: GNU General Public License v3.0 (GPL-3.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-wrapper-sqlite-0.1.40-1.src.rpm
checksum_type: sha256
description:
  _Part of the `database_wrapper` package._

  This python package is a database wrapper for [sqlite](https://www.sqlite.org/) database.



  This package is not yet implemented. The README is a placeholder for future implementation.



  ```bash
  pip install database_wrapper[sqlite]
  ```



  ```python
  from database_wrapper_sqlite import Sqlite, DBWrapperSqlite

  db = Sqlite({
      "database": "my_database.db",
  })
  db.open()
  dbWrapper = DBWrapperSqlite(db=db)


  aModel = MyModel()
  res = await dbWrapper.getByKey(
      aModel,
      "id",
      3005,
  )
  if res:
      print(f"getByKey: {res.toDict()}")
  else:
      print("No results")


  res = await dbWrapper.getAll(
      aModel,
      customQuery="""
          SELECT t1.*, t2.name AS other_name
          FROM my_table AS t1
          LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
      """
  )
  async for record in res:
      print(f"getAll: {record.toDict()}")
  else:
      print("No results")

  db.close()
  ```


pkgId: fa260293d31ee489e09e23e0f8edc02587e5f091c1c92eb29fa260d185d67805
name: python-database-wrapper-sqlite
arch: src
version: 0.1.72
epoch: 0
release: 1
summary: database_wrapper for PostgreSQL database
url: https://github.com/gintsmurans/py_database_wrapper
rpm_license: GNU General Public License v3.0 (GPL-3.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-database-wrapper-sqlite-0.1.72-1.src.rpm
checksum_type: sha256
description:
  _Part of the `database_wrapper` package._

  This python package is a database wrapper for [sqlite](https://www.sqlite.org/) database.



  This package is not yet implemented. The README is a placeholder for future implementation.



  ```bash
  pip install database_wrapper[sqlite]
  ```



  ```python
  from database_wrapper_sqlite import Sqlite, DBWrapperSqlite

  db = Sqlite({
      "database": "my_database.db",
  })
  db.open()
  dbWrapper = DBWrapperSqlite(dbCursor=db.cursor)


  aModel = MyModel()
  res = await dbWrapper.getByKey(
      aModel,
      "id",
      3005,
  )
  if res:
      print(f"getByKey: {res.toDict()}")
  else:
      print("No results")


  res = await dbWrapper.getAll(
      aModel,
      customQuery="""
          SELECT t1.*, t2.name AS other_name
          FROM my_table AS t1
          LEFT JOIN other_table AS t2 ON t1.other_id = t2.id
      """
  )
  async for record in res:
      print(f"getAll: {record.toDict()}")
  else:
      print("No results")

  db.close()
  ```


pkgId: 57b07f73e2601dae2446519108efbd960c7465e7e7a2c084343b53e46d5683a2
name: python-databaseConnectorUniversal
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: A python package for connecting with database.
url: https://github.com/MukhtarulHussain2000/mongoDBconnector_pkg
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databaseConnectorUniversal-0.0.4-1.src.rpm
checksum_type: sha256
description:
  It makes it easier to install and manage dependencies for development and testing, separate from the dependencies required for production.



  requirements.txt is used to specify the dependencies required to run the production code of a Python project, while requirements_dev.txt is used to specify the dependencies required for development and testing purposes.


  We use if for the testing in the python package testing against different version of the python


  1. Install depedencies and packages
  2. Run commands
  3. Its a combination of the (virtualenvwrapper and makefile)
  4. It creates a .tox



  it is being used for configuration the python project it is a alternative of the setup.cfg file. its containts configuration related to the build system
  such as the build tool used package name version author license and dependencies


  In summary, setup.cfg is used by setuptools to configure the packaging and installation of a Python projec


  *types of testing*
  1. Automated testing
  2. Manual testing

  *Mode of testing*
  1. Unit testing
  2. Integration tests

  *Testing frameworks*

  1. pytest
  2. unittest
  3. robotframework
  4. selenium
  5. behave
  6. doctest



  1. pylint
  2. flake8(it is best because it containt 3 library pylint pycodestyle mccabe)
  3. pycodestyle


pkgId: a6da55005a659fddfed887d752dfe6b3972f8d6f35368ea38cb77009e2fe2642
name: python-databased
arch: src
version: 4.3.8
epoch: 0
release: 1
url: https://github.com/matt-manes/databased
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databased-4.3.8-1.src.rpm
checksum_type: sha256
summary:
  Wrapper for the standard library Sqlite3 module to make setting up and using a database quicker and easier.

description:
  add_column  describe     properties  schema                    size
  backup      drop_column  query       select                    sys
  customize   drop_table   quit        set_connection_timeout    update
  dbpath      flush_log    restore     set_detect_types          use
  delete      help         scan        set_enforce_foreign_keys  vacuum
  Unrecognized commands will be executed as queries.
  Use the `query` command explicitly if you don't want to capitalize your key words.
  All transactions initiated by commands are committed immediately.
  chi.db>help schema
  Print out the names of the database tables, their columns, and, optionally, the number of rows.
  Parser help for schema:
  usage: dbshell [-h] [-t [TABLES ...]] [-c]
  options:
    -h, --help            show this help message and exit
    -t [TABLES ...], --tables [TABLES ...]
                          Only display info for this table(s).
    -c, --rowcount        Count and display the number of rows for each table.
  chi.db>schema -c
  Getting database schema...
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | Table Name           | Columns                                                                                                              | Number of Rows   |
  +======================+======================================================================================================================+==================+
  | business_addresses   | id, street, zip, ward, latitude, longitude                                                                           | 13276            |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | businesses           | account_number, legal_name, dba, address_id                                                                          | 14696            |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | license_codes        | code, description                                                                                                    | 146              |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | license_statuses     | id, status, description                                                                                              | 5                |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | licenses             | license_number, account_number, start_date, expiration_date, issue_date, status_id, status_change_date, license_code | 20120            |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | facility_types       | id, name                                                                                                             | 243              |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | risk_levels          | id, name                                                                                                             | 5                |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | facility_addresses   | id, street, zip, latitude, longitude, facility_type_id, risk_id                                                      | 13036            |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | inspected_businesses | id, license_number, dba, aka                                                                                         | 20120            |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | inspection_types     | id, name                                                                                                             | 16               |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | result_types         | id, description                                                                                                      | 7                |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | inspections          | id, license_number, facility_address_id, inspection_type_id, result_type_id, date                                    | 80016            |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | violation_types      | id, name                                                                                                             | 64               |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  | violations           | id, inspection_id, violation_type_id, comment                                                                        | 312471           |
  +----------------------+----------------------------------------------------------------------------------------------------------------------+------------------+
  chi.db>select violation_types -o "id DESC" -l 5
  Querying violation_types...
  Found 5 rows:
  +------+----------------------------------------------------+
  | id   | name                                               |
  +======+====================================================+
  | 64   | Miscellaneous / Public Health Orders               |
  +------+----------------------------------------------------+
  | 63   | Removal Of Suspension Sign                         |
  +------+----------------------------------------------------+
  | 62   | Compliance With Clean Indoor Air Ordinance         |
  +------+----------------------------------------------------+
  | 61   | Summary Report Displayed And Visible To The Public |
  +------+----------------------------------------------------+
  | 60   | Previous Core Violation Corrected                  |
  +------+----------------------------------------------------+
  5 rows from violation_types
  chi.db>SELECT * FROM violation_types ORDER BY id DESC LIMIT 5;
  +------+----------------------------------------------------+
  | id   | name                                               |
  +======+====================================================+
  | 64   | Miscellaneous / Public Health Orders               |
  +------+----------------------------------------------------+
  | 63   | Removal Of Suspension Sign                         |
  +------+----------------------------------------------------+
  | 62   | Compliance With Clean Indoor Air Ordinance         |
  +------+----------------------------------------------------+
  | 61   | Summary Report Displayed And Visible To The Public |
  +------+----------------------------------------------------+
  | 60   | Previous Core Violation Corrected                  |
  +------+----------------------------------------------------+
  ```
  The `customize` command or the `custom_shell` script can be used to generate a template file in the current directory that subclasses `DBManager`.
  This allows for project specific additional commands as well as modifications of available commands.


pkgId: 00fd0094997c5d786f14e7eff80a8ad96e2f68be90c9df30d8361371e5c47b3a
name: python-databases
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Async database support for Python.
url: https://github.com/encode/databases
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databases-0.9.0-1.src.rpm
checksum_type: sha256
description:
  ```shell
  $ pip install databases
  ```
  Database drivers supported are:
  * [asyncpg][asyncpg]
  * [aiopg][aiopg]
  * [aiomysql][aiomysql]
  * [asyncmy][asyncmy]
  * [aiosqlite][aiosqlite]
  You can install the required database drivers with:
  ```shell
  $ pip install databases[asyncpg]
  $ pip install databases[aiopg]
  $ pip install databases[aiomysql]
  $ pip install databases[asyncmy]
  $ pip install databases[aiosqlite]
  ```


pkgId: 9e0b3c08c96e39429dff6a341ab6a13ab30eab2c2d9fdfbc0a7e940cd393a828
name: python-databasetools
arch: src
version: 1.4.6
epoch: 0
release: 1
summary: Convenient data storage toolkit.
url: https://github.com/mrstephenneal/databasetools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databasetools-1.4.6-1.src.rpm
checksum_type: sha256
description:
  A collection of database tools written in Python for handling basic actions with CSV files, numpy dictionaries, SQLite databases and MySQL databases.


pkgId: ba700a7a5639d4f83ccf59933f6a3f5553ee87f70535b58276c29aac076517b8
name: python-databeaver
arch: src
version: 0.2.11
epoch: 0
release: 1
summary: Data Model Orchestration
url: https://opensource.fuzzybumblebee.org/databeaver/latest
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databeaver-0.2.11-1.src.rpm
checksum_type: sha256
description:
  DataBeaver is a tool that allows teams to easily realize, test, version, and share their data models.


  The aim of data beaver is to create a deterministic process for realizing a given data model.
  Data beaver can be used as easily a command line utility or integrated into your application via the DataBeaver class.


  To install Data Beaver you can run the command below.
  ```bash
  pip install databeaver
  ```



  * Build your data model - Traditionally creating your data was a labor intensive process. First you would write some sql
  then you would run the manually one by one. With Data Beaver a simple `beaver build` command will generate all the models
  in their correct order, respecting dependencies.
  * (Not Yet) Visualize Model Dependencies - In a large model it can be tricky to keep track on what tables depend on what
  other tables. Instead of trying to keep track of that yourself, let DataBeaver extract it directly from the sql and generate
  and image file for you all with the simple `beaver visualize` command



  Before we start we need to create the basic directory structure needed and a configuration file that can be edited.

  *Command*
  ```bash
  beaver create-project --name=<projectName>
  ```



  Data Beaver can be used as either a command line application or as a module for a more direct integration.

  ```python
  from databeaver import DataModel
  model = DataModel()
  model.build()
  ```




  | Version | Goal |Status|
  |---------|----------------------------------------------------------|------|
  |0.1.0    | Add the command line utility 'beaver' and 'DataBeaver' class |In Progress|
  |0.2.0    | Build a Model against in Postgres                        ||
  |0.3.0    | Build database models in MySQL                           ||


  | Version | Purpose                                                                       |
  |---------|-------------------------------------------------------------------------------|
  |0.0.37   | DataBeaver.build() now returns info on the models and files that were processed |


  [Classes](./docs/classes.md)<br>
  [Configuration](./docs/configuration.md)


pkgId: 116ead2295858e57f4ea4cea9a1387fa93ed66db32f4abedbff1298e4d3eed7a
name: python-databench-eval
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Evaluation framework for DataBench
url: https://github.com/jorses/databench
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databench-eval-2.1.1-1.src.rpm
checksum_type: sha256
description:
  This repo contains a simple evaluation framework for the DataBench suite for QA over Tabular Data.
  It is intended to provide a common framework and language to train and evaluate approaches to the task.

  Since the task is very open and a number of decisions need to be taken in order to standardize for in
  very different approaches, I've developed a simple framework so that only three decisions need to be taken:
  * How to **build the prompt** given a question and the dataset that contains the answer
  * The actual **model call** (with batch support)
  * The **evaluation function** since what constitutes a valid answer is very system-dependant.

  We also streamline prompt generation and processing, so we have a good setup to iterate.



  ````
  pip install databench-eval
  ````



  ```python
  from databench_eval import Runner, Evaluator

  def model_call(prompts: list[str]) -> list[str]:
      """ Call your model on a batch of prompts here. """
      return "'mock response'" * len(prompts)

  responses = Runner(model_call).run(prompts)

  acc = Evaluator().eval(responses)
  acc_lite = Evaluator().eval(responses, lite=True)
  ```

  For more complex usage making use of the features described below, please refer to the examples folder.


  The runner is the class that calls the model.


  If no QA is provided, it will download the full QA set from databench_eval.
  You can choose any QA subset you might like, for example
  ```python
  from databench_eval import Runner, Evaluator
  from databench_eval.utils import load_qa

  qa = load_qa(name="semeval", split="dev")

  Runner(model_call, qa=qa_dev).run()
  ```


  Instead of prompts, you might pass a `prompt_generator` function to the Runner.
  This receives a row from the qa dataset and is
  expected to return a string containing the prompt.

  This might be useful to quickly prototype or test out new prompts.
  For example, testing the effect of knowing (or not) the semantic beforehand in
  the function calls.

  ```python
  from databench_eval.utils import load_table
  def example_generator(row: dict) -> str:

      df = load_table(row["dataset"])
      question = row["question"]
      semantic = row["type"]
      return f'''
      
      def answer(df: pd.DataFrame) -> {semantic}:
          """Returns the answer to {question}"""
          df.columns = {list(df.columns)}
          return'''
  custom_runner = Runner(model_call, prompt_generator=prompt_generator)
  ```



  Similarly, you might implement a preprocess or postprocessing function for the model responses.
  For example, let's say we have a model with a tendency to just continue rambling after providing us with the answer, and we've observed the result is greatly enhanced by just taking the first line.

  By default, no postprocessing is implemented.

  ```python
  from databench_eval import Runner

  def custom_postp(response: str, dataset: str):
      return response.split("\n")[0]

  custom_runner = Runner(model_call, postprocess=custom_postp)
  ```

  The actual returns of the model_calls will be stored in Runner.raw_responses,
  while the



  By default, the Runner processes the dataset in batches of 10. You can change this by setting the `batch_size` parameter when initializing it.



  You can save the model responses to a txt file. The format will be that used during the SemEval 2025 competition,
  one result per line.
  ```
  Runner.run(..., save="/path/to/responses.txt")
  ```



  In the end how accurate or useful a model is to you heavily depends on what you want to do with the model responses.
  For example, someone looking to implement a solution that couples to a wider automated system where output format is key might want their responses
  to have a perfect very specific format, while other applications like chatbots would get away with any kind of format as long as a human could
  understand it.



  We have provided a basic evaluation function that is meant to serve as base evaluator,
  and can be found in Evaluator.default_compare:
  * Numbers are truncated to the second decimal 23.1234 == 23.12
  * Categories are compared as-is
  * The order within the lists is not taken into account

  This will be the function used to evaluate results in the Task 8 of SemEval 2025.

  The eval function of the evaluator can be overridden, either by monkey-patching or by using the `compare` argument in the Evaluator instantiation.

  As a very simple example of the kind of behaviour that we could customize,
  let's say that we're looking for literal strict evaluations, but not taking into account order in lists. We would do something like the following:

  ```python
  from databench_eval import Evaluator

  def custom_compare(value, truth, semantic=None):
      """ Custom evaluation function. """
      if "list" in semantic:
          return sorted(value) == sorted(truth)
      else:
          return str(value) == str(truth)

  custom_evaluator = Evaluator(compare=custom_compare)
  ```




  You can also read from a file by passing the path to it.
  The format expected will be that used during the SemEval 2025 competition,
  one result per line.
  ```python
  Evaluator().eval(..., save="path/to/file.txt")
  ```



  By default, the Evaluator processes the dataset in batches of 10. You can change this by setting the `batch_size` parameter when initializing it.




  Although decoupled from the main classes, I've included a couple of useful functions in here.
  The main functions are:

  * load_qa: load the qa sets from HuggingFace
  * load_table: loads a data table from a given id (the "dataset" column of the QA table) from HuggingFace

  HF is supposed to download each file only once, then just read from the cache, but in my own testing it has been
  faster to just download the files locally and then passing the
  Still I've decided to include the utils since they are convenient for easier testing.



  Check out the `examples` folder for more complex showcases of this library.
  `llamacpp.py` in particular carries out a full semeval 2025 task 8 submission.


  This benchmark is still in active development and at the early stages of usage.
  If you find any mistakes please let me know.

  The easiest way to reach me is at jorgeosesgrijalba@gmail.com


pkgId: 64657a23c5dd9977c9f43c484ceaf9bc734195e4c4aee4816913e97d41ee6b36
name: python-databend-py
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Python driver with native interface for Databend
url: https://github.com/databendcloud/databend-py
rpm_license: Apache License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databend-py-0.6.2-1.src.rpm
checksum_type: sha256
description:
  Databend Cloud Python Driver with native http interface support

  [![image](https://img.shields.io/pypi/v/databend-py.svg)](https://pypi.org/project/databend-py)

  [![image](https://coveralls.io/repos/github/databendcloud/databend-py/badge.svg?branch=master)](https://coveralls.io/github/databendcloud/databend-py?branch=master)

  [![image](https://img.shields.io/pypi/l/databend-py.svg)](https://pypi.org/project/databend-py)

  [![image](https://img.shields.io/pypi/pyversions/databend-py.svg)](https://pypi.org/project/databend-py)



  pip install databend-py



  Use the next code to check connection:

  > ``` python
  > >>> from databend_py import Client
  > >>> client = Client(
  >     host='tenant--warehouse.ch.datafusecloud.com',
  >     database="default",
  >     user="user",
  >     port="443",
  >     secure=True,
  >     password="password",settings={"copy_purge":True,"force":True})
  > >>> print(client.execute("SELECT 1"))
  > ```

  The [host]{.title-ref}, [user]{.title-ref}, [password]{.title-ref} info
  will be found in databend cloud warehouse connect page as flows:

  Pure Client example:

  > ``` python
  > >>> from databend_py import Client
  > >>>
  > >>> client = Client.from_url('http://root@localhost:8000/db?secure=False&copy_purge=True')
  > >>>
  > >>> client.execute('SHOW TABLES')
  > [[], [('test',)]]
  > >>> client.execute("show tables",with_column_types=True)
  > [[('Tables_in_default', 'String')], [('test',)]] # [[(column_name, column_type)], [(data,)]]
  > >>> client.execute('DROP TABLE IF EXISTS test')
  > []
  > >>> client.execute('CREATE TABLE test (x Int32)')
  > []
  > >>> client.execute(
  > ...     'INSERT INTO test (x) VALUES', [(1,)]
  > ... )
  > 1
  > >>> client.execute('INSERT INTO test (x) VALUES', [(200,)])
  > 1
  > ```

  More usages examples find [here](./examples).



  -   Basic SQL.
  -   TLS support.
  -   Query settings.
  -   Types support:
      -   Float32/64
      -   \[U\]Int8/16/32/64/128/256
      -   Date/Date32/DateTime(\'timezone\')/DateTime64(\'timezone\')
      -   String
      -   Array(T)
      -   Nullable(T)
      -   Bool



  -   If databend version \>= v0.9.0 or later, you need to use databend-py
      version \>= v0.3.0.



  Databend Python Driver is distributed under the [Apache
  license]{.title-ref}.


pkgId: 7b63f6e756e2cbf53526546731062ce058bcd2d43e973adeb676fd9a2bb3b15e
name: python-databend-udf
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Databend UDF Server
url: https://databend.rs
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databend-udf-0.2.6-1.src.rpm
checksum_type: sha256
description:
  ```python
  from databend_udf import *


  @udf(input_types=["VARCHAR", "VARCHAR", "VARCHAR"], result_type="VARCHAR")
  def split_and_join(s: str, split_s: str, join_s: str) -> str:
      return join_s.join(s.split(split_s))


  @udf(
      input_types=["INT", "INT"],
      result_type="INT",
      skip_null=True,
  )
  def gcd(x: int, y: int) -> int:
      while y != 0:
          (x, y) = (y, x % y)
      return x


  @udf(
      input_types=["ARRAY(INT64 NULL)", "INT64"],
      result_type="INT NOT NULL",
      skip_null=False,
  )
  def array_index_of(array: List[int], item: int):
      if array is None:
          return 0

      try:
          return array.index(item) + 1
      except ValueError:
          return 0


  @udf(input_types=["INT"], result_type="INT", io_threads=32)
  def wait_concurrent(x):
      
      time.sleep(2)
      return x

  if __name__ == '__main__':
      
      server = UDFServer("0.0.0.0:8815")
      
      server.add_function(split_and_join)
      server.add_function(gcd)
      server.add_function(array_index_of)
      server.add_function(wait_concurrent)
      
      server.serve()
  ```

  `@udf` is an annotation for creating a UDF. It supports following parameters:

  - input_types: A list of strings or Arrow data types that specifies the input data types.
  - result_type: A string or an Arrow data type that specifies the return value type.
  - name: An optional string specifying the function name. If not provided, the original name will be used.
  - io_threads: Number of I/O threads used per data chunk for I/O bound functions.
  - skip_null: A boolean value specifying whether to skip NULL value. If it is set to True, NULL values will not be passed to the function, and the corresponding return value is set to NULL. Default to False.


  Then we can Start the UDF Server by running:
  ```sh
  python3 udf_server.py
  ```


  Now, udf server is disabled by default in databend. You can enable it by setting 'enable_udf_server = true' in query node config.

  In addition, for security reasons, only the address specified in the config can be accessed by databend. The list of allowed udf server addresses are specified through the `udf_server_allowlist` variable in the query node config.

  Here is an example config:
  ```
  [query]
  ...
  enable_udf_server = true
  udf_server_allow_list = [ "http://0.0.0.0:8815", "http://example.com" ]
  ```


  We can use the `CREATE FUNCTION` command to add the functions you defined to Databend:
  ```
  CREATE FUNCTION [IF NOT EXISTS] <udf_name> (<arg_type>, ...) RETURNS <return_type> LANGUAGE <language> HANDLER=<handler> ADDRESS=<udf_server_address>
  ```
  The `udf_name` is the name of UDF you declared in Databend. The `handler` is the function name you defined in the python UDF server.

  For example:
  ```sql
  CREATE FUNCTION split_and_join (VARCHAR, VARCHAR, VARCHAR) RETURNS VARCHAR LANGUAGE python HANDLER = 'split_and_join' ADDRESS = 'http://0.0.0.0:8815';
  ```

  NOTE: The udf_server_address you specify must appear in `udf_server_allow_list` explained in the previous step.

  > In step 2, when you starting the UDF server, the corresponding sql statement of each function will be printed out. You can use them directly.


  ```
  mysql> select split_and_join('3,5,7', ',', ':');
  +-----------------------------------+
  | split_and_join('3,5,7', ',', ':') |
  +-----------------------------------+
  | 3:5:7                             |
  +-----------------------------------+
  ```



  The data types supported by the Python UDF API and their corresponding python types are as follows :

  | SQL Type            | Python Type       |
  | ------------------- | ----------------- |
  | BOOLEAN             | bool              |
  | TINYINT (UNSIGNED)  | int               |
  | SMALLINT (UNSIGNED) | int               |
  | INT (UNSIGNED)      | int               |
  | BIGINT (UNSIGNED)   | int               |
  | FLOAT               | float             |
  | DOUBLE              | float             |
  | DECIMAL             | decimal.Decimal   |
  | DATE                | datetime.date     |
  | TIMESTAMP           | datetime.datetime |
  | VARCHAR             | str               |
  | BINARY              | bytes             |
  | VARIANT             | any               |
  | MAP(K,V)            | dict              |
  | ARRAY(T)            | list[T]           |
  | TUPLE(T...)         | tuple(T...)       |

  The NULL in sql is represented by None in Python.




  ```sh

  python3 examples/server.py
  ```

  ```sh
  ./target/debug/databend-sqllogictests --run_dir udf_server
  ```



  Databend Python UDF Server API is inspired by [RisingWave Python API](https://pypi.org/project/risingwave/).


pkgId: 67320d11ce8cdfaad2cce93c5373e914b3b1ce954fe34b2b4bbfbda7205c61e7
name: python-databento
arch: src
version: 0.43.1
epoch: 0
release: 1
summary: Official Python client library for Databento
url: https://databento.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databento-0.43.1-1.src.rpm
checksum_type: sha256
description:
  [![test](https://github.com/databento/databento-python/actions/workflows/test.yml/badge.svg?branch=dev)](https://github.com/databento/databento-python/actions/workflows/test.yml)
  ![python](https://img.shields.io/badge/python-3.9+-blue.svg)
  [![pypi-version](https://img.shields.io/pypi/v/databento)](https://pypi.org/project/databento)
  [![license](https://img.shields.io/github/license/databento/databento-python?color=blue)](./LICENSE)
  [![code-style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Slack](https://img.shields.io/badge/join_Slack-community-darkblue.svg?logo=slack)](https://to.dbn.to/slack)

  The official Python client library for [Databento](https://databento.com).

  Key features include:
  - Fast, lightweight access to both live and historical data from [multiple markets](https://databento.com/docs/faqs/venues-and-publishers).
  - [Multiple schemas](https://databento.com/docs/schemas-and-data-formats/whats-a-schema?historical=python&live=python) such as MBO, MBP, top of book, OHLCV, last sale, and more.
  - [Fully normalized](https://databento.com/docs/standards-and-conventions/normalization?historical=python&live=python), i.e. identical message schemas for both live and historical data, across multiple asset classes.
  - Provides mappings between different symbology systems, including [smart symbology](https://databento.com/docs/api-reference-historical/basics/symbology?historical=python&live=python) for futures rollovers.
  - [Point-in-time]() instrument definitions, free of look-ahead bias and retroactive adjustments.
  - Reads and stores market data in an extremely efficient file format using [Databento Binary Encoding](https://databento.com/docs/standards-and-conventions/databento-binary-encoding?historical=python&live=python).
  - Event-driven [market replay](https://databento.com/docs/api-reference-historical/helpers/bento-replay?historical=python&live=python), including at high-frequency order book granularity.
  - Support for [batch download](https://databento.com/docs/faqs/streaming-vs-batch-download?historical=python&live=python) of flat files.
  - Support for [pandas](https://pandas.pydata.org/docs/), CSV, and JSON.


  The best place to begin is with our [Getting started](https://databento.com/docs/quickstart?historical=python&live=python) guide.

  You can find our full client API reference on the [Historical Reference](https://databento.com/docs/api-reference-historical?historical=python&live=python) and
  [Live Reference](https://databento.com/docs/reference-live?historical=python&live=python) sections of our documentation. See also the
  [Examples](https://databento.com/docs/examples?historical=python&live=python) section for various tutorials and code samples.


  The library is fully compatible with the latest distribution of Anaconda 3.9 and above.
  The minimum dependencies as found in the `pyproject.toml` are also listed below:
  - python = "^3.9"
  - aiohttp = "^3.8.3"
  - databento-dbn = "0.22.1"
  - numpy= ">=1.23.5"
  - pandas = ">=1.5.3"
  - pip-system-certs = ">=4.0" (Windows only)
  - pyarrow = ">=13.0.0"
  - requests = ">=2.25.1"
  - zstandard = ">=0.21.0"


  To install the latest stable version of the package from PyPI:

      pip install -U databento


  The library needs to be configured with an API key from your account.
  [Sign up](https://databento.com/signup) for free and you will automatically
  receive a set of API keys to start with. Each API key is a 32-character
  string starting with `db-`, that can be found on the API Keys page of your [Databento user portal](https://databento.com/platform/keys).

  A simple Databento application looks like this:

  ```python
  import databento as db

  client = db.Historical('YOUR_API_KEY')
  data = client.timeseries.get_range(
      dataset='GLBX.MDP3',
      symbols='ES.FUT',
      stype_in='parent',
      start='2022-06-10T14:30',
      end='2022-06-10T14:40',
  )

  data.replay(callback=print)  # market replay, with `print` as event handler
  ```

  Replace `YOUR_API_KEY` with an actual API key, then run this program.

  This uses `.replay()` to access the entire block of data
  and dispatch each data event to an event handler. You can also use
  `.to_df()` or `.to_ndarray()` to cast the data into a Pandas `DataFrame` or numpy `ndarray`:

  ```python
  df = data.to_df()  # to DataFrame
  array = data.to_ndarray()  # to ndarray
  ```

  Note that the API key was also passed as a parameter, which is
  [not recommended for production applications](https://databento.com/docs/portal/api-keys?historical=python&live=python).
  Instead, you can leave out this parameter to pass your API key via the `DATABENTO_API_KEY` environment variable:

  ```python
  import databento as db


  client = db.Historical('YOUR_API_KEY')


  client = db.Historical()
  ```


  Distributed under the [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0.html).


pkgId: d67a959dd162ddc5071c2081780e40f96ba5826ae40510e65b02263a06c688d1
name: python-databento
arch: src
version: 0.45.0
epoch: 0
release: 1
summary: Official Python client library for Databento
url: https://databento.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databento-0.45.0-1.src.rpm
checksum_type: sha256
description:
  [![test](https://github.com/databento/databento-python/actions/workflows/test.yml/badge.svg?branch=dev)](https://github.com/databento/databento-python/actions/workflows/test.yml)
  ![python](https://img.shields.io/badge/python-3.9+-blue.svg)
  [![pypi-version](https://img.shields.io/pypi/v/databento)](https://pypi.org/project/databento)
  [![license](https://img.shields.io/github/license/databento/databento-python?color=blue)](./LICENSE)
  [![code-style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Slack](https://img.shields.io/badge/join_Slack-community-darkblue.svg?logo=slack)](https://to.dbn.to/slack)

  The official Python client library for [Databento](https://databento.com).

  Key features include:
  - Fast, lightweight access to both live and historical data from [multiple markets](https://databento.com/docs/faqs/venues-and-publishers).
  - [Multiple schemas](https://databento.com/docs/schemas-and-data-formats/whats-a-schema?historical=python&live=python) such as MBO, MBP, top of book, OHLCV, last sale, and more.
  - [Fully normalized](https://databento.com/docs/standards-and-conventions/normalization?historical=python&live=python), i.e. identical message schemas for both live and historical data, across multiple asset classes.
  - Provides mappings between different symbology systems, including [smart symbology](https://databento.com/docs/api-reference-historical/basics/symbology?historical=python&live=python) for futures rollovers.
  - [Point-in-time]() instrument definitions, free of look-ahead bias and retroactive adjustments.
  - Reads and stores market data in an extremely efficient file format using [Databento Binary Encoding](https://databento.com/docs/standards-and-conventions/databento-binary-encoding?historical=python&live=python).
  - Event-driven [market replay](https://databento.com/docs/api-reference-historical/helpers/bento-replay?historical=python&live=python), including at high-frequency order book granularity.
  - Support for [batch download](https://databento.com/docs/faqs/streaming-vs-batch-download?historical=python&live=python) of flat files.
  - Support for [pandas](https://pandas.pydata.org/docs/), CSV, and JSON.


  The best place to begin is with our [Getting started](https://databento.com/docs/quickstart?historical=python&live=python) guide.

  You can find our full client API reference on the [Historical Reference](https://databento.com/docs/api-reference-historical?historical=python&live=python) and
  [Live Reference](https://databento.com/docs/reference-live?historical=python&live=python) sections of our documentation. See also the
  [Examples](https://databento.com/docs/examples?historical=python&live=python) section for various tutorials and code samples.


  The library is fully compatible with the latest distribution of Anaconda 3.9 and above.
  The minimum dependencies as found in the `pyproject.toml` are also listed below:
  - python = "^3.9"
  - aiohttp = "^3.8.3"
  - databento-dbn = "0.23.1"
  - numpy= ">=1.23.5"
  - pandas = ">=1.5.3"
  - pip-system-certs = ">=4.0" (Windows only)
  - pyarrow = ">=13.0.0"
  - requests = ">=2.25.1"
  - zstandard = ">=0.21.0"


  To install the latest stable version of the package from PyPI:

      pip install -U databento


  The library needs to be configured with an API key from your account.
  [Sign up](https://databento.com/signup) for free and you will automatically
  receive a set of API keys to start with. Each API key is a 32-character
  string starting with `db-`, that can be found on the API Keys page of your [Databento user portal](https://databento.com/platform/keys).

  A simple Databento application looks like this:

  ```python
  import databento as db

  client = db.Historical('YOUR_API_KEY')
  data = client.timeseries.get_range(
      dataset='GLBX.MDP3',
      symbols='ES.FUT',
      stype_in='parent',
      start='2022-06-10T14:30',
      end='2022-06-10T14:40',
  )

  data.replay(callback=print)  # market replay, with `print` as event handler
  ```

  Replace `YOUR_API_KEY` with an actual API key, then run this program.

  This uses `.replay()` to access the entire block of data
  and dispatch each data event to an event handler. You can also use
  `.to_df()` or `.to_ndarray()` to cast the data into a Pandas `DataFrame` or numpy `ndarray`:

  ```python
  df = data.to_df()  # to DataFrame
  array = data.to_ndarray()  # to ndarray
  ```

  Note that the API key was also passed as a parameter, which is
  [not recommended for production applications](https://databento.com/docs/portal/api-keys?historical=python&live=python).
  Instead, you can leave out this parameter to pass your API key via the `DATABENTO_API_KEY` environment variable:

  ```python
  import databento as db


  client = db.Historical('YOUR_API_KEY')


  client = db.Historical()
  ```


  Distributed under the [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0.html).


pkgId: d03c86ebe53fb0e1b1b1fd79d0b545ab6408b8ea9c0c70418cdc175782cea66b
name: python-databind
arch: src
version: 4.5.2
epoch: 0
release: 1
description: <p align="center">Copyright &copy; 2022 &ndash; Niklas Rosenstein</p>
url: https://pypi.org/project/databind/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databind-4.5.2-1.src.rpm
checksum_type: sha256
summary:
  Databind is a library inspired by jackson-databind to de-/serialize Python dataclasses. The `databind` package will install the full suite of databind packages. Compatible with Python 3.8 and newer.


pkgId: acf2812ef99a5f7ef3988fee5103a299b939db2308b604758952cf4985f428fb
name: python-databooks
arch: src
version: 1.3.10
epoch: 0
release: 1
summary: A CLI tool to resolve git conflicts and remove metadata in notebooks.
url: https://datarootsio.github.io/databooks/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databooks-1.3.10-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://datarootsio.github.io/databooks/"><img alt="logo" src="https://raw.githubusercontent.com/datarootsio/databooks/main/docs/images/logo.png"></a>
  </p>
  <p align="center">
    <a href="https://dataroots.io"><img alt="Maintained by dataroots" src="https://dataroots.io/maintained-rnd.svg" /></a>
    <a href="https://pypi.org/project/databooks/"><img alt="Python versions" src="https://img.shields.io/pypi/pyversions/databooks" /></a>
    <a href="https://pypi.org/project/databooks/"><img alt="PiPy" src="https://img.shields.io/pypi/v/databooks" /></a>
    <a href="https://pepy.tech/project/databooks"><img alt="Downloads" src="https://pepy.tech/badge/databooks" /></a>
    <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg" /></a>
    <a href="http://mypy-lang.org/"><img alt="Mypy checked" src="https://img.shields.io/badge/mypy-checked-1f5082.svg" /></a>
    <a href="https://pepy.tech/project/databooks"><img alt="Codecov" src="https://codecov.io/github/datarootsio/databooks/main/graph/badge.svg" /></a>
    <a href="https://github.com/datarootsio/databooks/actions"><img alt="test" src="https://github.com/datarootsio/databooks/actions/workflows/test.yml/badge.svg" /></a>
  </p>


  `databooks` is a package to ease the collaboration between data scientists using
  [Jupyter notebooks](https://jupyter.org/), by reducing the number of git conflicts between
  different notebooks and resolution of git conflicts when encountered.

  The key features include:

  - CLI tool
    - Clear notebook metadata
    - Resolve git conflicts
  - Simple to use
  - Simple API for using modelling and comparing notebooks using [Pydantic](https://pydantic-docs.helpmanual.io/)



  `databooks` is built on top of:

  - Python 3.7+
  - [Typer](https://typer.tiangolo.com/)
  - [Rich](https://rich.readthedocs.io/en/latest/)
  - [Pydantic](https://pydantic-docs.helpmanual.io/)
  - [GitPython](https://gitpython.readthedocs.io/en/stable/tutorial.html)
  - [Tomli](https://github.com/hukkin/tomli)



  ```
  pip install databooks
  ```





  Simply specify the paths for notebook files to remove metadata. By doing so, we can
  already avoid many of the conflicts.

  ```console
  $ databooks meta [OPTIONS] PATHS...
  ```

  ![databooks meta demo](https://raw.githubusercontent.com/datarootsio/databooks/main/docs/images/databooks-meta.gif)



  Specify the paths for notebook files with conflicts to be fixed. Then, `databooks` finds
  the source notebooks that caused the conflicts and compares them (so no JSON manipulation!)

  ```console
  $ databooks fix [OPTIONS] PATHS...
  ```

  ![databooks fix demo](https://raw.githubusercontent.com/datarootsio/databooks/main/docs/images/databooks-fix.gif)



  Specify paths of notebooks to be checked, an expression or recipe of what you'd like to
  enforce. `databooks` will run your checks and raise errors if any notebook does not
  comply with the desired metadata values. This advanced feature allows users to enforce
  cell tags, sequential cell execution, maximum number of cells, among many other things!

  Check out our [docs](https://databooks.dev/latest/usage/overview/#databooks-assert) for more!

  ```console
  $ databooks assert [OPTIONS] PATHS...
  ```

  ![databooks assert demo](https://raw.githubusercontent.com/datarootsio/databooks/main/docs/images/databooks-assert.gif)



  Instead of launching Jupyter and opening the browser to inspect notebooks, have a quick
  look at them in the terminal. All you need is to specify the path(s) of the notebook(s).

  ```console
  $ databooks show [OPTIONS] PATHS...
  ```

  ![databooks show demo](https://raw.githubusercontent.com/datarootsio/databooks/main/docs/images/databooks-show.gif)



  Similar to git diff, but for notebooks! Show a rich diff of the notebooks in the
  terminal. Works for comparing git index with the current working directory, comparing
  branches or blobs.

  ```console
  $ databooks diff [OPTIONS] [REF_BASE] [REF_REMOTE] [PATHS]...
  ```

  ![databooks diff demo](https://raw.githubusercontent.com/datarootsio/databooks/main/docs/images/databooks-diff.gif)



  This project is licensed under the terms of the MIT license.


pkgId: 885eb08aed395fba0ac201be5f914a2c1e368868c65e5cdddd5f858097c7df4c
name: python-databoomer
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Copy Python objects as portable code snippets between Jupyter notebooks
url: https://github.com/KKallas/DataBoomer
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databoomer-0.1.1-1.src.rpm
checksum_type: sha256
description:
  A Jupyter tool for seamlessly transferring complex Python objects between notebooks. DataBoomer serializes your objects as base64 string and creates self-contained code snippets that can perfectly recreate them in any notebook.


  - One-click copying of serialized objects to clipboard
  - Handles complex Python objects using `dill`
  - Creates self-contained, portable code snippets
  - Automatically detects variable names
  - Preserves object state exactly as it was


  ```bash
  pip install databoomer
  ```


  ```python
  from databoomer import DataBoomer
  import pandas as pd


  df = pd.DataFrame({'values': [1, 2, 3]})
  df['processed'] = df['values'] * 2
  DataBoomer(df, comment="Preprocessed dataset")






  model = train_complex_model()
  DataBoomer(model, obj_name="trained_model", comment="Model trained on XYZ dataset")


  ```


  - **Share Objects**: Easily transfer complex objects between notebooks
  - **Session Recovery**: Save important objects in a format that survives kernel restarts
  - **Collaboration**: Share exact object states with colleagues
  - **State Preservation**: Captures complete object state, including custom attributes and processing

  Remember: DataBoomer creates portable, self-contained code snippets that recreate your objects exactly as they were. Just boom it, switch notebooks, paste, and you're ready to go.

  Note: This tool is particularly useful when working with objects that are:
  - Result of complex processing
  - Trained models or fitted transformers
  - Custom class instances with specific state
  - Image snippets, selfcontained in the jupyter lab


pkgId: 8676452f7191ce4defc2aa14439eb5a554e3791b1a9ac4c9114a1c88df58667d
name: python-databricks-api
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Databricks API client auto-generated from the official databricks-cli package
url: https://github.com/crflynn/databricks-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-api-0.9.0-1.src.rpm
checksum_type: sha256
description:
  **Please switch to the official Databricks SDK for Python (https://github.com/databricks/databricks-sdk-py) by running the following command:**
      pip install databricks-sdk
  |pypi| |pyversions|
  *[This documentation is auto-generated]*
  This package provides a simplified interface for the Databricks REST API.
  The interface is autogenerated on instantiation using the underlying client
  library used in the official ``databricks-cli`` python package.
  Install using
      pip install databricks-api
  The docs here describe the interface for version **0.17.0** of
  the ``databricks-cli`` package for API version **2.0**.
  The ``databricks-api`` package contains a ``DatabricksAPI`` class which provides
  instance attributes for the ``databricks-cli`` ``ApiClient``, as well as each of
  the available service instances. The attributes of a ``DatabricksAPI`` instance are:
  * DatabricksAPI.client *<databricks_cli.sdk.api_client.ApiClient>*
  * DatabricksAPI.jobs *<databricks_cli.sdk.service.JobsService>*
  * DatabricksAPI.cluster *<databricks_cli.sdk.service.ClusterService>*
  * DatabricksAPI.policy *<databricks_cli.sdk.service.PolicyService>*
  * DatabricksAPI.managed_library *<databricks_cli.sdk.service.ManagedLibraryService>*
  * DatabricksAPI.dbfs *<databricks_cli.sdk.service.DbfsService>*
  * DatabricksAPI.workspace *<databricks_cli.sdk.service.WorkspaceService>*
  * DatabricksAPI.secret *<databricks_cli.sdk.service.SecretService>*
  * DatabricksAPI.groups *<databricks_cli.sdk.service.GroupsService>*
  * DatabricksAPI.token *<databricks_cli.sdk.service.TokenService>*
  * DatabricksAPI.instance_pool *<databricks_cli.sdk.service.InstancePoolService>*
  * DatabricksAPI.delta_pipelines *<databricks_cli.sdk.service.DeltaPipelinesService>*
  * DatabricksAPI.repos *<databricks_cli.sdk.service.ReposService>*
  To instantiate the client, provide the databricks host and either a token or
  user and password. Also shown is the full signature of the
  underlying ``ApiClient.__init__``
      from databricks_api import DatabricksAPI
      
      db = DatabricksAPI(
          host="example.cloud.databricks.com",
          token="dpapi123..."
      )
      
      db = DatabricksAPI(
          host="example.cloud.databricks.com",
          user="me@example.com",
          password="password"
      )
      
      db = DatabricksAPI(
          user=None,
          password=None,
          host=None,
          token=None,
          api_version='2.0',
          default_headers={},
          verify=True,
          command_name='',
          jobs_api_version=None
      )
  Refer to the `official documentation <https://docs.databricks.com/api/index.html>`_
  on the functionality and required arguments of each method below.
  Each of the service instance attributes provides the following public methods:


pkgId: 471ec476b4203c2103f6863813f0e231445b6fe86f8254de7ff6ffe154adf0fc
name: python-databricks-cli
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: A command line interface for Databricks
url: https://github.com/databricks/databricks-cli
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-cli-0.18.0-1.src.rpm
checksum_type: sha256
description:
  The Databricks Command Line Interface (CLI) is an open source tool which provides an easy to use interface to
  the Databricks platform. The CLI is built on top of the Databricks REST APIs.
  **Note**: This CLI is no longer under active development and has been released as an experimental client.
  Please leave bug reports as issues on our `GitHub project <https://github.com/databricks/databricks-cli>`_.


pkgId: 0a1d6f3b17274dc4c7f3b3bc558cfd9c8e642a98750c98ef8a20bb69c198e448
name: python-databricks-dash
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A Public stub for databricks-dash by Plotly
url: https://plotly.com/dash/
rpm_license: Commercial
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-dash-0.0.1-1.src.rpm
checksum_type: sha256
description:
  databricks-dash is a part of [Dash Enterprise](https://plotly.com/dash/),
  Plotly's end-to-end Dash application platform. This public copy of the package
  is a stub published on pypi.org designed to shield Dash Enterprise users from
  [dependency confusion](https://medium.com/@alex.birsan/dependency-confusion-4a5d60fec610),
  a remote code execution attack publicly disclosed in 2021 by Alex Birsan.

  If you are a Dash Enterprise user, you will only see this public package if your
  app is not properly configured to find the local package repository built into
  Dash Enterprise. Visit the docs for your Dash Enterprise installation for details.

  If you never see this public package, it's still doing its job of protecting you
  from the dependency confusion attack!


pkgId: 098c31c9dc5cf6671fd5f983f76dabedb533aef28282df09218d97d161d06a3b
name: python-databricks-dbapi
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: A DBAPI 2.0 interface and SQLAlchemy dialect for Databricks interactive clusters.
url: https://github.com/crflynn/databricks-dbapi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-dbapi-0.6.0-1.src.rpm
checksum_type: sha256
description:
  |pypi| |pyversions|
  A thin wrapper around `pyhive <https://github.com/dropbox/PyHive>`__ and `pyodbc <https://github.com/mkleehammer/pyodbc>`__ for creating a `DBAPI <https://www.python.org/dev/peps/pep-0249/>`__ connection to Databricks Workspace and SQL Analytics clusters. SQL Analytics clusters require the `Simba ODBC driver <https://databricks.com/spark/odbc-driver-download>`__.
  Also provides SQLAlchemy Dialects using ``pyhive`` and ``pyodbc`` for Databricks clusters. Databricks SQL Analytics clusters only support the ``pyodbc``-driven dialect.


pkgId: 7ba4d9d16358f10f7a90658f49189de309f2580df45dbc856b28d0035be3fba6
name: python-databricks-environment
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Databricks Environment for pyspark apps
url: https://pypi.org/project/databricks-environment/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-environment-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Set of basic environment-specific functions



  1. `conda env create -f environment.yml -p .venv`
  1. `conda activate $PWD/.venv`
  1. `poetry install --no-root`



  1. `poe black`


pkgId: 10a2cdb45a225aa6fd44427304a8a641fc5e65f0a34c4991517f3f09635ace44
name: python-databricks-feature-engineering
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Databricks Feature Engineering Client
url: https://pypi.org/project/databricks-feature-engineering/
rpm_license: Databricks Proprietary License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-feature-engineering-0.8.0-1.src.rpm
checksum_type: sha256
description:
  The Databricks Feature Engineering client is used to:
  * Create, read, and write feature tables
  * Train models on feature data
  * Publish feature tables to online stores for real-time serving
  * Upgrade workspace feature table metadata to Unity Catalog



  Documentation can be found per-cloud at:
  - [AWS](https://docs.databricks.com/applications/machine-learning/feature-store/index.html)
  - [Azure](https://docs.microsoft.com/en-us/azure/databricks/applications/machine-learning/feature-store/)
  - [GCP](https://docs.gcp.databricks.com/applications/machine-learning/feature-store/index.html)

  For release notes, see
  - [AWS](https://docs.databricks.com/release-notes/feature-store/databricks-feature-store.html)
  - [Azure](https://docs.microsoft.com/en-us/azure/databricks/release-notes/feature-store/databricks-feature-store)
  - [GCP](https://docs.gcp.databricks.com/release-notes/feature-store/databricks-feature-store.html)



  This library can only run on Databricks runtimes. It can be installed locally or in CI/CD environments for unit testing.

  **DB license**

  Copyright (2022) Databricks, Inc.

  This library (the "Software") may not be used except in connection with the Licensee's use of the Databricks Platform Services
  pursuant to an Agreement (defined below) between Licensee (defined below) and Databricks, Inc. ("Databricks"). This Software
  shall be deemed part of the Downloadable Services under the Agreement, or if the Agreement does not define Downloadable Services,
  Subscription Services, or if neither are defined then the term in such Agreement that refers to the applicable Databricks Platform
  Services (as defined below) shall be substituted herein for "Downloadable Services". Licensee's use of the Software must comply at
  all times with any restrictions applicable to the Downlodable Services and Subscription Services, generally, and must be used in
  accordance with any applicable documentation.

  Additionally, and notwithstanding anything in the Agreement to the contrary:
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
  IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  If you have not agreed to an Agreement or otherwise do not agree to these terms, you may not use the Software.

  This license terminates automatically upon the termination of the Agreement or Licensee's breach of these terms.

  Agreement: the agreement between Databricks and Licensee governing the use of the Databricks Platform Services, which shall be, with
  respect to Databricks, the Databricks Terms of Service located at www.databricks.com/termsofservice, and with respect to Databricks
  Community Edition, the Community Edition Terms of Service located at www.databricks.com/ce-termsofuse, in each case unless Licensee
  has entered into a separate written agreement with Databricks governing the use of the applicable Databricks Platform Services.

  Databricks Platform Services: the Databricks services or the Databricks Community Edition services, according to where the Software is used.

  Licensee: the user of the Software, or, if the Software is being used on behalf of a company, the company.


pkgId: 736ce444994a7ed8777ecbe8ae54e0ada4107b0ad5b3275ab53eca4b52d2cef6
name: python-databricks-filesystem
arch: src
version: 0.0.4
epoch: 0
release: 1
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-filesystem-0.0.4-1.src.rpm
checksum_type: sha256
summary:
  Databricks Utils does not support few crucial file system operations like recursive directory listing, pattern-matching for files, listing only directories or files, and more. This package provides seamless execution of these tasks.

description:
  Databricks stands out as a leading service for big data processing, yet it lacks support for several essential file system operations commonly needed by developers. Consequently, developers often have to craft custom solutions to fill this gap. The missing operations include:
  - Recursively listing directory contents
  - Listing files matching specified start and end patterns
  - Performing case-sensitive or case-insensitive file pattern matches
  - Listing only directories or only files or both
  - Generating sorted output of listing
  Fortunately, with the availability of this package, you can effortlessly execute these operations.

url:
  https://medium.com/data-engineer-things/finally-in-databricks-we-can-now-perform-recursive-directory-listing-and-many-more-operations-c5f32aad78e7


pkgId: a9ecb515e694300652bd80f572b0c3cbdfe1a0d37178f50b4b5fd5bc258fe34f
name: python-databricks-genai-inference
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Interact with the Databricks Foundation Model API from python
url: https://docs.databricks.com/en/machine-learning/foundation-models/query-foundation-model-apis.html
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-genai-inference-0.2.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/databricks-genai-inference.svg)](https://pypi.org/project/databricks-genai-inference/)

  The Databricks Generative AI Inference Python library provides a user-friendly python interface to use the Databricks [Foundation Model API](https://docs.databricks.com/en/machine-learning/foundation-models/api-reference.html).

  > [!NOTE]
  > This SDK was primarily designed for pay-per-token endpoints (`databricks-*`). It has a list of known model names (eg. `dbrx-instruct`) and automatically maps them to the corresponding shared endpoint (`databricks-dbrx-instruct`).
  > You can use this with provisioned throughput endpoints, as long as they do not match known model names.
  > If there is an overlap, you can use the `DATABRICKS_MODEL_URL_ENV` URL to directly provide an endpoint URL.

  This library includes a pre-defined set of API classes `Embedding`, `Completion`, `ChatCompletion` with convenient functions to make API request, and to parse contents from raw json response.

  We also offer a high level `ChatSession` object for easy management of multi-round chat completions, which is especially useful for your next chatbot development.

  You can find more usage details in our [SDK onboarding doc](https://docs.databricks.com/en/machine-learning/foundation-models/query-foundation-model-apis.html).

  > [!IMPORTANT]
  > We're preparing to release version 1.0 of the Databricks GenerativeAI Inference Python library.



  ```sh
  pip install databricks-genai-inference
  ```





  ```python
  from databricks_genai_inference import Embedding
  ```



  ```python
  response = Embedding.create(
      model="bge-large-en",
      input="3D ActionSLAM: wearable person tracking in multi-floor environments")
  print(f'embeddings: {response.embeddings[0]}')
  ```

  > [!TIP]
  > You may want to reuse http connection to improve request latency for large-scale workload, code example:

  ```python
  with requests.Session() as client:
      for i, text in enumerate(texts):
          response = Embedding.create(
              client=client,
              model="bge-large-en",
              input=text
          )
  ```



  ```python
  async with httpx.AsyncClient() as client:
      response = await Embedding.acreate(
          client=client,
          model="bge-large-en",
          input="3D ActionSLAM: wearable person tracking in multi-floor environments")
      print(f'embeddings: {response.embeddings[0]}')
  ```



  ```python
  response = Embedding.create(
      model="bge-large-en",
      instruction="Represent this sentence for searching relevant passages:",
      input="3D ActionSLAM: wearable person tracking in multi-floor environments")
  print(f'embeddings: {response.embeddings[0]}')
  ```



  > [!IMPORTANT]
  > Support max batch size of 150

  ```python
  response = Embedding.create(
      model="bge-large-en",
      input=[
          "3D ActionSLAM: wearable person tracking in multi-floor environments",
          "3D ActionSLAM: wearable person tracking in multi-floor environments"])
  print(f'response.embeddings[0]: {response.embeddings[0]}\n')
  print(f'response.embeddings[1]: {response.embeddings[1]}')
  ```



  > [!IMPORTANT]
  > Support one instruction per batch
  > Batch size

  ```python
  response = Embedding.create(
      model="bge-large-en",
      instruction="Represent this sentence for searching relevant passages:",
      input=[
          "3D ActionSLAM: wearable person tracking in multi-floor environments",
          "3D ActionSLAM: wearable person tracking in multi-floor environments"])
  print(f'response.embeddings[0]: {response.embeddings[0]}\n')
  print(f'response.embeddings[1]: {response.embeddings[1]}')
  ```



  ```python
  from databricks_genai_inference import Completion
  ```



  ```python
  response = Completion.create(
      model="mpt-7b-instruct",
      prompt="Represent the Science title:")
  print(f'response.text:{response.text:}')

  ```



  ```python
  async with httpx.AsyncClient() as client:
      response = await Completion.acreate(
          client=client,
          model="mpt-7b-instruct",
          prompt="Represent the Science title:")
      print(f'response.text:{response.text:}')

  ```



  > [!IMPORTANT]
  > Only support batch size = 1 in streaming mode

  ```python
  response = Completion.create(
      model="mpt-7b-instruct",
      prompt="Count from 1 to 100:",
      stream=True)
  print(f'response.text:')
  for chunk in response:
      print(f'{chunk.text}', end="")
  ```



  ```python
  async with httpx.AsyncClient() as client:
      response = await Completion.acreate(
          client=client,
          model="mpt-7b-instruct",
          prompt="Count from 1 to 10:",
          stream=True)
      print(f'response.text:')
      async for chunk in response:
          print(f'{chunk.text}', end="")

  ```




  > [!IMPORTANT]
  > Support max batch size of 16

  ```python
  response = Completion.create(
      model="mpt-7b-instruct",
      prompt=[
          "Represent the Science title:",
          "Represent the Science title:"])
  print(f'response.text[0]:{response.text[0]}')
  print(f'response.text[1]:{response.text[1]}')
  ```



  ```python
  from databricks_genai_inference import ChatCompletion
  ```

  > [!IMPORTANT]
  > Batching is not supported for `ChatCompletion`



  ```python
  response = ChatCompletion.create(model="llama-2-70b-chat", messages=[{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Knock knock."}])
  print(f'response.text:{response.message:}')
  ```



  ```python
  async with httpx.AsyncClient() as client:
      response = await ChatCompletion.acreate(
          client=client,
          model="llama-2-70b-chat",
          messages=[{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Knock knock."}],
      )
      print(f'response.text:{response.message:}')
  ```



  ```python
  response = ChatCompletion.create(model="llama-2-70b-chat", messages=[{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Count from 1 to 30, add one emoji after each number"}], stream=True)
  for chunk in response:
      print(f'{chunk.message}', end="")
  ```



  ```python
  async with httpx.AsyncClient() as client:
      response = await ChatCompletion.acreate(
          client=client,
          model="llama-2-70b-chat",
          messages=[{"role": "system", "content": "You are a helpful assistant."},{"role": "user", "content": "Count from 1 to 30, add one emoji after each number"}],
          stream=True,
      )
      async for chunk in response:
          print(f'{chunk.message}', end="")
  ```



  ```python
  from databricks_genai_inference import ChatSession
  ```

  > [!IMPORTANT]
  > Streaming mode is not supported for `ChatSession`

  ```python
  chat = ChatSession(model="llama-2-70b-chat")
  chat.reply("Kock, kock!")
  print(f'chat.last: {chat.last}')
  chat.reply("Take a guess!")
  print(f'chat.last: {chat.last}')

  print(f'chat.history: {chat.history}')
  print(f'chat.count: {chat.count}')
  ```


pkgId: db1c73fb127d61d40c45cb1ea9ebaa68d45fffae7e574d3017f533bfb567c263
name: python-databricks-google-sheets
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Interact with Google Sheets from Databricks
url: https://github.com/vbalasu/databricks-google-sheets
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-google-sheets-0.8.0-1.src.rpm
checksum_type: sha256
description:
  Interact with Google Sheets from Databricks.

  Please follow these steps. Be sure to replace all {{PLACEHOLDERS}} with appropriate values:

  1. Create a spreadsheet in Google Sheets, and note the spreadsheet_id (You can get this from the URL)
  2. Go to console.cloud.google.com and create a new project (OR select an existing project)
  3. Within this project, create a service account [IAM & Admin --> Service Accounts --> Create], and call it `databricks-google-sheets`. You can skip the optional steps
  4. Note down the email address associated with your new service account. Eg. `databricks-google-sheets@{{MY-AWESOME-PROJECT}}.iam.gserviceaccount.com`
  5. Switch to the Keys tab and create a new key. Choose JSON as the Key type. This will generate a JSON file and download it locally
  6. On your local machine, use the Databricks CLI to create a new secret scope. Eg. `databricks secrets create-scope --scope databricks-google-sheets --profile DEFAULT`
  7. Create a new secret within the newly created secret scope. Eg. `databricks secrets put --scope databricks-google-sheets --key "databricks-google-sheets@{{MY-AWESOME-PROJECT}}.iam.gserviceaccount.com" --binary-file {{PATH-TO-JSON-FILE-FROM-STEP-5}} --profile DEFAULT`
  8. Share your Google Sheet with the user `databricks-google-sheets@{{MY-AWESOME-PROJECT}}.iam.gserviceaccount.com`, and give Editor privileges





  ```python
  from databricks_google_sheets import DatabricksGoogleSheets
  dgs = DatabricksGoogleSheets(dbutils)  # Pass in dbutils from the global scope of your Databricks runtime



  df = spark.sql("SELECT 'Hello from databricks-google-sheets' greeting;").toPandas()


  import pandas as pd
  df = pd.DataFrame({'greeting': ['Hello from databricks-google-sheets']})


  dgs.df_to_sheets(df, spreadsheet_id='{{SPREADSHEET-ID-FROM-STEP-1}}', sheet_name='test',
      dbsecret_scope='databricks-google-sheets', dbsecret_key='databricks-google-sheets@{{MY-AWESOME-PROJECT}}.iam.gserviceaccount.com')


  newdf = dgs.sheets_to_df(spreadsheet_id='{{SPREADSHEET-ID-FROM-STEP-1}}', sheet_name='test',
      dbsecret_scope='databricks-google-sheets', dbsecret_key='databricks-google-sheets@{{MY-AWESOME-PROJECT}}.iam.gserviceaccount.com')


  assert df.equals(newdf) == True
  ```


pkgId: 40a065da30c5813c6bcaeb04cb0ef3d143860bd5de3cfac9aad5a53932e91e15
name: python-databricks-mosaic-gdal
arch: src
version: 3.4.3
epoch: 0
release: 1
summary: GDAL install with Java Bindings for Databricks Runtime 11+
url: https://github.com/databrickslabs/mosaic/modules/python/gdal
rpm_license: Databricks License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-mosaic-gdal-3.4.3-1.src.rpm
checksum_type: sha256
description:
  > Current version is 3.4.3 (to match GDAL).

  This is a filetree (vs apt based) drop-in packaging of GDAL with Java Bindings from [UbuntuGIS PPA](https://launchpad.net/~ubuntugis/+archive/ubuntu/ubuntugis-unstable) for Ubuntu 20.04 (Focal Fossa) which is used by [Databricks Runtime](https://docs.databricks.com/release-notes/runtime/releases.html)(DBR) 11+.  __Note: This is a very specific packaging for GDAL + dependencies which removes any libraries that are already provided by DBR, so not useful outside Databricks.__

  1. `gdal-3.4.3-filetree.tar.xz` is ~50MB - it is extracted with `tar -xf gdal-3.4.3-filetree.tar.xz -C /`
  2. `gdal-3.4.3.-symlinks.tar.xz` is ~19MB - it is extracted with `tar -xhf gdal-3.4.3-symlinks.tar.xz -C /`

  An example [init script](https://docs.databricks.com/clusters/init-scripts.html) is provided at `./resources/scripts/mosaic-gdal-3.4.3-filetree-init.sh` for managing install of the tarballs across a DBR cluster.


pkgId: 937ae73e7cae8182e3aae5b4aaee89aa6dfbb9e7ccfc8758a908216d741a1d4b
name: python-databricks-rocket
arch: src
version: 3.0.4
epoch: 0
release: 1
url: https://github.com/getyourguide/db-rocket
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-rocket-3.0.4-1.src.rpm
checksum_type: sha256
summary:
  Keep your local python scripts installed and in sync with a databricks notebook. Shortens the feedback loop to develop projects using a hybrid enviroment

description:
  <img src="https://user-images.githubusercontent.com/2252355/173396060-8ebb3a33-f389-421d-bea4-afc01a078307.svg" width="100" height="100">

  [![PyPI version](https://badge.fury.io/py/databricks-rocket.svg)](https://badge.fury.io/py/databricks-rocket)
  ![PyPI downloads](https://img.shields.io/pypi/dm/databricks-rocket)

  Databricks-Rocket (short db-rockets), keeps your local Python scripts installed and synchronized with a Databricks notebook. Every change on your local machine
  is automatically reflected in the notebook. This shortens the feedback loop for developing git-based projects and
  eliminates the need to set up a local development environment.



  Install `databricks-rocket` using pip:

  ```sh
  pip install databricks-rocket
  ```



  Ensure you've created a personal access token in
  Databricks ([offical documentation](https://docs.databricks.com/dev-tools/cli/index.html)). Afterward, set up the
  Databricks CLI by executing:

  ```sh
  databricks configure --token
  ```

  Alternatively, you can set the Databricks token and host in your environment variables:

  ```sh
  export DATABRICKS_HOST="mydatabrickshost"
  export DATABRICKS_TOKEN="mydatabrickstoken"
  ```

  If your project isn't already a pip package, you'll need to convert it into one. Use dbrocket for this:

  ```sh
  rocket setup
  ```

  Will create a setup.py for you.





  By default, `databricks-rocket` syncs your project to DBFS automatically. This allows you to update your code and have
  those changes reflected in your Databricks notebook without restarting the Python kernel. Simply execute:

  ```sh
  rocket launch
  ```

  You'll then receive the exact command to run in your notebook. Example:

  ```sh
  stevenmi@MacBook db-rocket % rocket launch --watch=False
  >> Watch activated. Uploaded your project to databricks. Install your project in your databricks notebook by running:
  >> %pip install --upgrade pip
  >> %pip install  -r /dbfs/temp/stevenmi/db-rocket/requirements.txt
  >> %pip install --no-deps -e /dbfs/temp/stevenmi/db-rocket

  and following in a new Python cell:
  >> %load_ext autoreload
  >> %autoreload 2
  ```

  Finally, add the content in you databricks notebook:
  ![imgs/img_2.png](imgs/img_2.png)


  Upload all root level json files:
  ```shell
  rocket launch --glob_path="*,json"
  ```
  On top also upload all env files:
  ```shell
  rocket launch --glob_path="[\"*.json\", \".env*\"]"
  ```
  When specifying lists, be mindful about the formatting of the parameter string.



  If you've disabled the watch feature, `databricks-rocket` will only upload your project as a wheel to DBFS:

  ```sh
  rocket launch --watch=False
  ```

  Example:

  ```sh
  stevenmi@MacBook db-rocket % rocket launch --watch=False
  >> Watch is disabled. Building creating a python wheel from your project
  >> Found setup.py. Building python library
  >> Uploaded ./dist/databricks_rocket-2.0.0-py3-none-any.whl to dbfs:/temp/stevenmi/db-rocket/dist/databricks_rocket-2.0.0-py3-none-any.whl
  >> Uploaded wheel to databricks. Install your library in your databricks notebook by running:
  >> %pip install --upgrade pip
  >> %pip install  /dbfs/temp/stevenmi/db-rocket/databricks_rocket-2.0.0-py3-none-any.whl --force-reinstall
  ```



  - [DBrocket 2.0](https://www.getyourguide.careers/posts/improving-data-science-productivity-with-db-rocket-2-0): A summary of the big improvements we made to the tool in the new release.
  - [DB Rocket 1.0](https://www.getyourguide.careers/posts/open-sourcing-db-rocket-for-data-scientists) post also gives more details about the rationale around dbrocket.



  - Databricks: >=7
  - Python: >=3.7
  - Tested on Platform: Linux, MacOs. Windows will probably not work but contributions are welcomed!
  - Supports uploading to Unity Catalog Volumes starting from version 3.0.0. Note that the underlying dependency, `databricks-sdk`, is still in beta. We do not recommend using UC Volumes in production.



  - Thanks Leon Poli for the Logo :)
  - Thanks Stephane Leonard for source-code and documentation improvements :)
  - Thanks Malachi Soord for the CICD setup and README improvements

  Contributions are welcomed!




  For security issues please contact [security@getyourguide.com](mailto:security@getyourguide.com).



  db-rocket is licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE.txt) for the full text.


pkgId: 787a2392c5ea7f871796efb0d474f1f3c3d26457f16669bbfd5e2c2a84de4fdc
name: python-databricks-sdk
arch: src
version: 0.34.0
epoch: 0
release: 1
summary: Databricks SDK for Python (Beta)
url: https://databricks-sdk-py.readthedocs.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-sdk-0.34.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Downloads](https://img.shields.io/pypi/dw/databricks-sdk)](https://pypistats.org/packages/databricks-sdk)
  [![PyPI - License](https://img.shields.io/pypi/l/databricks-sdk)](https://github.com/databricks/databricks-sdk-py/blob/main/LICENSE)
  [![databricks-sdk](https://snyk.io/advisor/python/databricks-sdk/badge.svg)](https://snyk.io/advisor/python/databricks-sdk)
  ![PyPI](https://img.shields.io/pypi/v/databricks-sdk)
  [![codecov](https://codecov.io/gh/databricks/databricks-sdk-py/branch/main/graph/badge.svg?token=GU63K7WDBE)](https://codecov.io/gh/databricks/databricks-sdk-py)
  [![lines of code](https://tokei.rs/b1/github/databricks/databricks-sdk-py)]([https://codecov.io/github/databricks/databricks-sdk-py](https://github.com/databricks/databricks-sdk-py))

  [Beta](https://docs.databricks.com/release-notes/release-types.html): This SDK is supported for production use cases,
  but we do expect future releases to have some interface changes; see [Interface stability](#interface-stability).
  We are keen to hear feedback from you on these SDKs. Please [file issues](https://github.com/databricks/databricks-sdk-py/issues), and we will address them.
  | See also the [SDK for Java](https://github.com/databricks/databricks-sdk-java)
  | See also the [SDK for Go](https://github.com/databricks/databricks-sdk-go)
  | See also the [Terraform Provider](https://github.com/databricks/terraform-provider-databricks)
  | See also cloud-specific docs ([AWS](https://docs.databricks.com/dev-tools/sdk-python.html),
     [Azure](https://learn.microsoft.com/en-us/azure/databricks/dev-tools/sdk-python),
     [GCP](https://docs.gcp.databricks.com/dev-tools/sdk-python.html))
  | See also the [API reference on readthedocs](https://databricks-sdk-py.readthedocs.io/en/latest/)

  The Databricks SDK for Python includes functionality to accelerate development with [Python](https://www.python.org/) for the Databricks Lakehouse.
  It covers all public [Databricks REST API](https://docs.databricks.com/dev-tools/api/index.html) operations.
  The SDK's internal HTTP client is robust and handles failures on different levels by performing intelligent retries.



  - [Getting started](#getting-started)
  - [Code examples](#code-examples)
  - [Authentication](#authentication)
  - [Long-running operations](#long-running-operations)
  - [Paginated responses](#paginated-responses)
  - [Single-sign-on with OAuth](#single-sign-on-sso-with-oauth)
  - [User Agent Request Attribution](#user-agent-request-attribution)
  - [Error handling](#error-handling)
  - [Logging](#logging)
  - [Integration with `dbutils`](#interaction-with-dbutils)
  - [Interface stability](#interface-stability)



  1. Please install Databricks SDK for Python via `pip install databricks-sdk` and instantiate `WorkspaceClient`:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient()
  for c in w.clusters.list():
      print(c.cluster_name)
  ```

  Databricks SDK for Python is compatible with Python 3.7 _(until [June 2023](https://devguide.python.org/versions/))_, 3.8, 3.9, 3.10, and 3.11.
  **Note:** Databricks Runtime starting from version 13.1 includes a bundled version of the Python SDK.
  It is highly recommended to upgrade to the latest version which you can do by running the following in a notebook cell:

  ```python
  %pip install --upgrade databricks-sdk
  ```
  followed by
  ```python
  dbutils.library.restartPython()
  ```


  The Databricks SDK for Python comes with a number of examples demonstrating how to use the library for various common use-cases, including

  * [Using the SDK with OAuth from a webserver](https://github.com/databricks/databricks-sdk-py/blob/main/examples/flask_app_with_oauth.py)
  * [Using long-running operations](https://github.com/databricks/databricks-sdk-py/blob/main/examples/starting_job_and_waiting.py)
  * [Authenticating a client app using OAuth](https://github.com/databricks/databricks-sdk-py/blob/main/examples/local_browser_oauth.py)

  These examples and more are located in the [`examples/` directory of the Github repository](https://github.com/databricks/databricks-sdk-py/tree/main/examples).

  Some other examples of using the SDK include:
  * [Unity Catalog Automated Migration](https://github.com/databricks/ucx) heavily relies on Python SDK for working with Databricks APIs.
  * [ip-access-list-analyzer](https://github.com/alexott/databricks-playground/tree/main/ip-access-list-analyzer) checks & prunes invalid entries from IP Access Lists.



  If you use Databricks [configuration profiles](https://docs.databricks.com/dev-tools/auth.html#configuration-profiles)
  or Databricks-specific [environment variables](https://docs.databricks.com/dev-tools/auth.html#environment-variables)
  for [Databricks authentication](https://docs.databricks.com/dev-tools/auth.html), the only code required to start
  working with a Databricks workspace is the following code snippet, which instructs the Databricks SDK for Python to use
  its [default authentication flow](#default-authentication-flow):

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient()
  w. # press <TAB> for autocompletion
  ```

  The conventional name for the variable that holds the workspace-level client of the Databricks SDK for Python is `w`, which is shorthand for `workspace`.



  - [Default authentication flow](#default-authentication-flow)
  - [Databricks native authentication](#databricks-native-authentication)
  - [Azure native authentication](#azure-native-authentication)
  - [Overriding .databrickscfg](#overriding-databrickscfg)
  - [Additional authentication configuration options](#additional-authentication-configuration-options)



  If you run the [Databricks Terraform Provider](https://registry.terraform.io/providers/databrickslabs/databricks/latest),
  the [Databricks SDK for Go](https://github.com/databricks/databricks-sdk-go), the [Databricks CLI](https://docs.databricks.com/dev-tools/cli/index.html),
  or applications that target the Databricks SDKs for other languages, most likely they will all interoperate nicely together.
  By default, the Databricks SDK for Python tries the following [authentication](https://docs.databricks.com/dev-tools/auth.html) methods,
  in the following order, until it succeeds:

  1. [Databricks native authentication](#databricks-native-authentication)
  2. [Azure native authentication](#azure-native-authentication)
  4. If the SDK is unsuccessful at this point, it returns an authentication error and stops running.

  You can instruct the Databricks SDK for Python to use a specific authentication method by setting the `auth_type` argument
  as described in the following sections.

  For each authentication method, the SDK searches for compatible authentication credentials in the following locations,
  in the following order. Once the SDK finds a compatible set of credentials that it can use, it stops searching:

  1. Credentials that are hard-coded into configuration arguments.

     :warning: **Caution**: Databricks does not recommend hard-coding credentials into arguments, as they can be exposed in plain text in version control systems. Use environment variables or configuration profiles instead.

  2. Credentials in Databricks-specific [environment variables](https://docs.databricks.com/dev-tools/auth.html#environment-variables).
  3. For Databricks native authentication, credentials in the `.databrickscfg` file's `DEFAULT` [configuration profile](https://docs.databricks.com/dev-tools/auth.html#configuration-profiles) from its default file location (`~` for Linux or macOS, and `%USERPROFILE%` for Windows).
  4. For Azure native authentication, the SDK searches for credentials through the Azure CLI as needed.

  Depending on the Databricks authentication method, the SDK uses the following information. Presented are the `WorkspaceClient` and `AccountClient` arguments (which have corresponding `.databrickscfg` file fields), their descriptions, and any corresponding environment variables.



  By default, the Databricks SDK for Python initially tries [Databricks token authentication](https://docs.databricks.com/dev-tools/api/latest/authentication.html) (`auth_type='pat'` argument). If the SDK is unsuccessful, it then tries Databricks basic (username/password) authentication (`auth_type="basic"` argument).

  - For Databricks token authentication, you must provide `host` and `token`; or their environment variable or `.databrickscfg` file field equivalents.
  - For Databricks basic authentication, you must provide `host`, `username`, and `password` _(for AWS workspace-level operations)_; or `host`, `account_id`, `username`, and `password` _(for AWS, Azure, or GCP account-level operations)_; or their environment variable or `.databrickscfg` file field equivalents.

  | Argument     | Description | Environment variable |
  |--------------|-------------|-------------------|
  | `host`       | _(String)_ The Databricks host URL for either the Databricks workspace endpoint or the Databricks accounts endpoint. | `DATABRICKS_HOST` |
  | `account_id` | _(String)_ The Databricks account ID for the Databricks accounts endpoint. Only has effect when `Host` is either `https://accounts.cloud.databricks.com/` _(AWS)_, `https://accounts.azuredatabricks.net/` _(Azure)_, or `https://accounts.gcp.databricks.com/` _(GCP)_. | `DATABRICKS_ACCOUNT_ID` |
  | `token`      | _(String)_ The Databricks personal access token (PAT) _(AWS, Azure, and GCP)_ or Azure Active Directory (Azure AD) token _(Azure)_. | `DATABRICKS_TOKEN` |
  | `username`   | _(String)_ The Databricks username part of basic authentication. Only possible when `Host` is `*.cloud.databricks.com` _(AWS)_. | `DATABRICKS_USERNAME` |
  | `password`   | _(String)_ The Databricks password part of basic authentication. Only possible when `Host` is `*.cloud.databricks.com` _(AWS)_. | `DATABRICKS_PASSWORD` |

  For example, to use Databricks token authentication:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(host=input('Databricks Workspace URL: '), token=input('Token: '))
  ```



  By default, the Databricks SDK for Python first tries Azure client secret authentication (`auth_type='azure-client-secret'` argument). If the SDK is unsuccessful, it then tries Azure CLI authentication (`auth_type='azure-cli'` argument). See [Manage service principals](https://learn.microsoft.com/azure/databricks/administration-guide/users-groups/service-principals).

  The Databricks SDK for Python picks up an Azure CLI token, if you've previously authenticated as an Azure user by running `az login` on your machine. See [Get Azure AD tokens for users by using the Azure CLI](https://learn.microsoft.com/azure/databricks/dev-tools/api/latest/aad/user-aad-token).

  To authenticate as an Azure Active Directory (Azure AD) service principal, you must provide one of the following. See also [Add a service principal to your Azure Databricks account](https://learn.microsoft.com/azure/databricks/administration-guide/users-groups/service-principals#add-sp-account):

  - `azure_workspace_resource_id`, `azure_client_secret`, `azure_client_id`, and `azure_tenant_id`; or their environment variable or `.databrickscfg` file field equivalents.
  - `azure_workspace_resource_id` and `azure_use_msi`; or their environment variable or `.databrickscfg` file field equivalents.

  | Argument              | Description | Environment variable |
  |-----------------------|-------------|----------------------|
  | `azure_workspace_resource_id`   | _(String)_ The Azure Resource Manager ID for the Azure Databricks workspace, which is exchanged for a Databricks host URL. | `DATABRICKS_AZURE_RESOURCE_ID` |
  | `azure_use_msi`       | _(Boolean)_ `true` to use Azure Managed Service Identity passwordless authentication flow for service principals. _This feature is not yet implemented in the Databricks SDK for Python._ | `ARM_USE_MSI` |
  | `azure_client_secret` | _(String)_ The Azure AD service principal's client secret. | `ARM_CLIENT_SECRET` |
  | `azure_client_id`     | _(String)_ The Azure AD service principal's application ID. | `ARM_CLIENT_ID` |
  | `azure_tenant_id`     | _(String)_ The Azure AD service principal's tenant ID. | `ARM_TENANT_ID` |
  | `azure_environment`   | _(String)_ The Azure environment type (such as Public, UsGov, China, and Germany) for a specific set of API endpoints. Defaults to `PUBLIC`. | `ARM_ENVIRONMENT` |

  For example, to use Azure client secret authentication:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(host=input('Databricks Workspace URL: '),
                      azure_workspace_resource_id=input('Azure Resource ID: '),
                      azure_tenant_id=input('AAD Tenant ID: '),
                      azure_client_id=input('AAD Client ID: '),
                      azure_client_secret=input('AAD Client Secret: '))
  ```

  Please see more examples in [this document](./docs/azure-ad.md).



  By default, the Databricks SDK for Python first tries GCP credentials authentication (`auth_type='google-credentials'`, argument). If the SDK is unsuccessful, it then tries Google Cloud Platform (GCP) ID authentication (`auth_type='google-id'`, argument).

  The Databricks SDK for Python picks up an OAuth token in the scope of the Google Default Application Credentials (DAC) flow. This means that if you have run `gcloud auth application-default login` on your development machine, or launch the application on the compute, that is allowed to impersonate the Google Cloud service account specified in `google_service_account`. Authentication should then work out of the box. See [Creating and managing service accounts](https://cloud.google.com/iam/docs/creating-managing-service-accounts).

  To authenticate as a Google Cloud service account, you must provide one of the following:

  - `host` and `google_credentials`; or their environment variable or `.databrickscfg` file field equivalents.
  - `host` and `google_service_account`; or their environment variable or `.databrickscfg` file field equivalents.

  | Argument                 | Description | Environment variable |
  |--------------------------|-------------|--------------------------------------------------|
  | `google_credentials`     | _(String)_ GCP Service Account Credentials JSON or the location of these credentials on the local filesystem. | `GOOGLE_CREDENTIALS` |
  | `google_service_account` | _(String)_ The Google Cloud Platform (GCP) service account e-mail used for impersonation in the Default Application Credentials Flow that does not require a password. | `DATABRICKS_GOOGLE_SERVICE_ACCOUNT` |

  For example, to use Google ID authentication:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(host=input('Databricks Workspace URL: '),
                      google_service_account=input('Google Service Account: '))

  ```



  For [Databricks native authentication](#databricks-native-authentication), you can override the default behavior for using `.databrickscfg` as follows:

  | Argument      | Description | Environment variable |
  |---------------|-------------|----------------------|
  | `profile`     | _(String)_ A connection profile specified within `.databrickscfg` to use instead of `DEFAULT`. | `DATABRICKS_CONFIG_PROFILE` |
  | `config_file` | _(String)_ A non-default location of the Databricks CLI credentials file. | `DATABRICKS_CONFIG_FILE` |

  For example, to use a profile named `MYPROFILE` instead of `DEFAULT`:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(profile='MYPROFILE')

  ```



  For all authentication methods, you can override the default behavior in client arguments as follows:

  | Argument                | Description | Environment variable   |
  |-------------------------|-------------|------------------------|
  | `auth_type`             | _(String)_ When multiple auth attributes are available in the environment, use the auth type specified by this argument. This argument also holds the currently selected auth. | `DATABRICKS_AUTH_TYPE` |
  | `http_timeout_seconds`  | _(Integer)_ Number of seconds for HTTP timeout. Default is _60_. | _(None)_               |
  | `retry_timeout_seconds` | _(Integer)_ Number of seconds to keep retrying HTTP requests. Default is _300 (5 minutes)_. | _(None)_               |
  | `debug_truncate_bytes`  | _(Integer)_ Truncate JSON fields in debug logs above this limit. Default is 96. | `DATABRICKS_DEBUG_TRUNCATE_BYTES` |
  | `debug_headers`         | _(Boolean)_ `true` to debug HTTP headers of requests made by the application. Default is `false`, as headers contain sensitive data, such as access tokens. | `DATABRICKS_DEBUG_HEADERS` |
  | `rate_limit`            | _(Integer)_ Maximum number of requests per second made to Databricks REST API. | `DATABRICKS_RATE_LIMIT` |

  For example, to turn on debug HTTP headers:

  ```python
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(debug_headers=True)

  ```



  When you invoke a long-running operation, the SDK provides a high-level API to _trigger_ these operations and _wait_ for the related entities
  to reach the correct state or return the error message in case of failure. All long-running operations return generic `Wait` instance with `result()`
  method to get a result of long-running operation, once it's finished. Databricks SDK for Python picks the most reasonable default timeouts for
  every method, but sometimes you may find yourself in a situation, where you'd want to provide `datetime.timedelta()` as the value of `timeout`
  argument to `result()` method.

  There are a number of long-running operations in Databricks APIs such as managing:
  * Clusters,
  * Command execution
  * Jobs
  * Libraries
  * Delta Live Tables pipelines
  * Databricks SQL warehouses.

  For example, in the Clusters API, once you create a cluster, you receive a cluster ID, and the cluster is in the `PENDING` state Meanwhile
  Databricks takes care of provisioning virtual machines from the cloud provider in the background. The cluster is
  only usable in the `RUNNING` state and so you have to wait for that state to be reached.

  Another example is the API for running a job or repairing the run: right after
  the run starts, the run is in the `PENDING` state. The job is only considered to be finished when it is in either
  the `TERMINATED` or `SKIPPED` state. Also you would likely need the error message if the long-running
  operation times out and fails with an error code. Other times you may want to configure a custom timeout other than
  the default of 20 minutes.

  In the following example, `w.clusters.create` returns `ClusterInfo` only once the cluster is in the `RUNNING` state,
  otherwise it will timeout in 10 minutes:

  ```python
  import datetime
  import logging
  from databricks.sdk import WorkspaceClient

  w = WorkspaceClient()
  info = w.clusters.create_and_wait(cluster_name='Created cluster',
                                    spark_version='12.0.x-scala2.12',
                                    node_type_id='m5d.large',
                                    autotermination_minutes=10,
                                    num_workers=1,
                                    timeout=datetime.timedelta(minutes=10))
  logging.info(f'Created: {info}')
  ```

  Please look at the `examples/starting_job_and_waiting.py` for a more advanced usage:

  ```python
  import datetime
  import logging
  import time

  from databricks.sdk import WorkspaceClient
  import databricks.sdk.service.jobs as j

  w = WorkspaceClient()


  py_on_dbfs = f'/home/{w.current_user.me().user_name}/sample.py'
  with w.dbfs.open(py_on_dbfs, write=True, overwrite=True) as f:
      f.write(b'import time; time.sleep(10); print("Hello, World!")')


  waiter = w.jobs.submit(run_name=f'py-sdk-run-{time.time()}', tasks=[
      j.RunSubmitTaskSettings(
          task_key='hello_world',
          new_cluster=j.BaseClusterInfo(
              spark_version=w.clusters.select_spark_version(long_term_support=True),
              node_type_id=w.clusters.select_node_type(local_disk=True),
              num_workers=1
          ),
          spark_python_task=j.SparkPythonTask(
              python_file=f'dbfs:{py_on_dbfs}'
          ),
      )
  ])

  logging.info(f'starting to poll: {waiter.run_id}')


  def print_status(run: j.Run):
      statuses = [f'{t.task_key}: {t.state.life_cycle_state}' for t in run.tasks]
      logging.info(f'workflow intermediate status: {", ".join(statuses)}')









  run = waiter.result(timeout=datetime.timedelta(minutes=15),
                      callback=print_status)

  logging.info(f'job finished: {run.run_page_url}')
  ```



  On the platform side the Databricks APIs have different wait to deal with pagination:
  * Some APIs follow the offset-plus-limit pagination
  * Some start their offsets from 0 and some from 1
  * Some use the cursor-based iteration
  * Others just return all results in a single response

  The Databricks SDK for Python hides this  complexity
  under `Iterator[T]` abstraction, where multi-page results `yield` items. Python typing helps to auto-complete
  the individual item fields.

  ```python
  import logging
  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient()
  for repo in w.repos.list():
      logging.info(f'Found repo: {repo.path}')
  ```

  Please look at the `examples/last_job_runs.py` for a more advanced usage:

  ```python
  import logging
  from collections import defaultdict
  from datetime import datetime, timezone
  from databricks.sdk import WorkspaceClient

  latest_state = {}
  all_jobs = {}
  durations = defaultdict(list)

  w = WorkspaceClient()
  for job in w.jobs.list():
      all_jobs[job.job_id] = job
      for run in w.jobs.list_runs(job_id=job.job_id, expand_tasks=False):
          durations[job.job_id].append(run.run_duration)
          if job.job_id not in latest_state:
              latest_state[job.job_id] = run
              continue
          if run.end_time < latest_state[job.job_id].end_time:
              continue
          latest_state[job.job_id] = run

  summary = []
  for job_id, run in latest_state.items():
      summary.append({
          'job_name': all_jobs[job_id].settings.name,
          'last_status': run.state.result_state,
          'last_finished': datetime.fromtimestamp(run.end_time/1000, timezone.utc),
          'average_duration': sum(durations[job_id]) / len(durations[job_id])
      })

  for line in sorted(summary, key=lambda s: s['last_finished'], reverse=True):
      logging.info(f'Latest: {line}')
  ```





  For a regular web app running on a server, it's recommended to use the Authorization Code Flow to obtain an Access Token
  and a Refresh Token. This method is considered safe because the Access Token is transmitted directly to the server
  hosting the app, without passing through the user's web browser and risking exposure.

  To enhance the security of the Authorization Code Flow, the PKCE (Proof Key for Code Exchange) mechanism can be
  employed. With PKCE, the calling application generates a secret called the Code Verifier, which is verified by
  the authorization server. The app also creates a transform value of the Code Verifier, called the Code Challenge,
  and sends it over HTTPS to obtain an Authorization Code. By intercepting the Authorization Code, a malicious attacker
  cannot exchange it for a token without possessing the Code Verifier.

  The [presented sample](https://github.com/databricks/databricks-sdk-py/blob/main/examples/flask_app_with_oauth.py)
  is a Python3 script that uses the Flask web framework along with Databricks SDK for Python to demonstrate how to
  implement the OAuth Authorization Code flow with PKCE security. It can be used to build an app where each user uses
  their identity to access Databricks resources. The script can be executed with or without client and secret credentials
  for a custom OAuth app.

  Databricks SDK for Python exposes the `oauth_client.initiate_consent()` helper to acquire user redirect URL and initiate
  PKCE state verification. Application developers are expected to persist `RefreshableCredentials` in the webapp session
  and restore it via `RefreshableCredentials.from_dict(oauth_client, session['creds'])` helpers.

  Works for both AWS and Azure. Not supported for GCP at the moment.

  ```python
  from databricks.sdk.oauth import OAuthClient

  oauth_client = OAuthClient(host='<workspace-url>',
                             client_id='<oauth client ID>',
                             redirect_url=f'http://host.domain/callback',
                             scopes=['clusters'])

  import secrets
  from flask import Flask, render_template_string, request, redirect, url_for, session

  APP_NAME = 'flask-demo'
  app = Flask(APP_NAME)
  app.secret_key = secrets.token_urlsafe(32)


  @app.route('/callback')
  def callback():
     from databricks.sdk.oauth import Consent
     consent = Consent.from_dict(oauth_client, session['consent'])
     session['creds'] = consent.exchange_callback_parameters(request.args).as_dict()
     return redirect(url_for('index'))


  @app.route('/')
  def index():
     if 'creds' not in session:
        consent = oauth_client.initiate_consent()
        session['consent'] = consent.as_dict()
        return redirect(consent.auth_url)

     from databricks.sdk import WorkspaceClient
     from databricks.sdk.oauth import SessionCredentials

     credentials_provider = SessionCredentials.from_dict(oauth_client, session['creds'])
     workspace_client = WorkspaceClient(host=oauth_client.host,
                                        product=APP_NAME,
                                        credentials_provider=credentials_provider)

     return render_template_string('...', w=workspace_client)
  ```



  For applications, that do run on developer workstations, Databricks SDK for Python provides `auth_type='external-browser'`
  utility, that opens up a browser for a user to go through SSO flow. Azure support is still in the early experimental
  stage.

  ```python
  from databricks.sdk import WorkspaceClient

  host = input('Enter Databricks host: ')

  w = WorkspaceClient(host=host, auth_type='external-browser')
  clusters = w.clusters.list()

  for cl in clusters:
      print(f' - {cl.cluster_name} is {cl.state}')
  ```



  In order to use OAuth with Databricks SDK for Python, you should use `account_client.custom_app_integration.create` API.

  ```python
  import logging, getpass
  from databricks.sdk import AccountClient
  account_client = AccountClient(host='https://accounts.cloud.databricks.com',
                                 account_id=input('Databricks Account ID: '),
                                 username=input('Username: '),
                                 password=getpass.getpass('Password: '))

  logging.info('Enrolling all published apps...')
  account_client.o_auth_enrollment.create(enable_all_published_apps=True)

  status = account_client.o_auth_enrollment.get()
  logging.info(f'Enrolled all published apps: {status}')

  custom_app = account_client.custom_app_integration.create(
      name='awesome-app',
      redirect_urls=[f'https://host.domain/path/to/callback'],
      confidential=True)
  logging.info(f'Created new custom app: '
               f'--client_id {custom_app.client_id} '
               f'--client_secret {custom_app.client_secret}')
  ```



  The Databricks SDK for Python uses the `User-Agent` header to include request metadata along with each request. By default, this includes the version of the Python SDK, the version of the Python language used by your application, and the underlying operating system. To statically add additional metadata, you can use the `with_partner()` and `with_product()` functions in the `databricks.sdk.useragent` module. `with_partner()` can be used by partners to indicate that code using the Databricks SDK for Go should be attributed to a specific partner. Multiple partners can be registered at once. Partner names can contain any number, digit, `.`, `-`, `_` or `+`.

  ```python
  from databricks.sdk import useragent
  useragent.with_product("partner-abc")
  useragent.with_partner("partner-xyz")
  ```

  `with_product()` can be used to define the name and version of the product that is built with the Databricks SDK for Python. The product name has the same restrictions as the partner name above, and the product version must be a valid [SemVer](https://semver.org/). Subsequent calls to `with_product()` replace the original product with the new user-specified one.

  ```go
  from databricks.sdk import useragent
  useragent.with_product("databricks-example-product", "1.2.0")
  ```

  If both the `DATABRICKS_SDK_UPSTREAM` and `DATABRICKS_SDK_UPSTREAM_VERSION` environment variables are defined, these will also be included in the `User-Agent` header.

  If additional metadata needs to be specified that isn't already supported by the above interfaces, you can use the `with_user_agent_extra()` function to register arbitrary key-value pairs to include in the user agent. Multiple values associated with the same key are allowed. Keys have the same restrictions as the partner name above. Values must be either as described above or SemVer strings.

  Additional `User-Agent` information can be associated with different instances of `DatabricksConfig`. To add metadata to a specific instance of `DatabricksConfig`, use the `with_user_agent_extra()` method.



  The Databricks SDK for Python provides a robust error-handling mechanism that allows developers to catch and handle API errors. When an error occurs, the SDK will raise an exception that contains information about the error, such as the HTTP status code, error message, and error details. Developers can catch these exceptions and handle them appropriately in their code.

  ```python
  from databricks.sdk import WorkspaceClient
  from databricks.sdk.errors import ResourceDoesNotExist

  w = WorkspaceClient()
  try:
      w.clusters.get(cluster_id='1234-5678-9012')
  except ResourceDoesNotExist as e:
      print(f'Cluster not found: {e}')
  ```

  The SDK handles inconsistencies in error responses amongst the different services, providing a consistent interface for developers to work with. Simply catch the appropriate exception type and handle the error as needed. The errors returned by the Databricks API are defined in [databricks/sdk/errors/platform.py](https://github.com/databricks/databricks-sdk-py/blob/main/databricks/sdk/errors/platform.py).



  The Databricks SDK for Python seamlessly integrates with the standard [Logging facility for Python](https://docs.python.org/3/library/logging.html).
  This allows developers to easily enable and customize logging for their Databricks Python projects.
  To enable debug logging in your Databricks Python project, you can follow the example below:

  ```python
  import logging, sys
  logging.basicConfig(stream=sys.stderr,
                      level=logging.INFO,
                      format='s [s][s] s')
  logging.getLogger('databricks.sdk').setLevel(logging.DEBUG)

  from databricks.sdk import WorkspaceClient
  w = WorkspaceClient(debug_truncate_bytes=1024, debug_headers=False)
  for cluster in w.clusters.list():
      logging.info(f'Found cluster: {cluster.cluster_name}')
  ```

  In the above code snippet, the logging module is imported and the `basicConfig()` method is used to set the logging level to `DEBUG`.
  This will enable logging at the debug level and above. Developers can adjust the logging level as needed to control the verbosity of the logging output.
  The SDK will log all requests and responses to standard error output, using the format `> ` for requests and `< ` for responses.
  In some cases, requests or responses may be truncated due to size considerations. If this occurs, the log message will include
  the text `... (XXX additional elements)` to indicate that the request or response has been truncated. To increase the truncation limits,
  developers can set the `debug_truncate_bytes` configuration property or the `DATABRICKS_DEBUG_TRUNCATE_BYTES` environment variable.
  To protect sensitive data, such as authentication tokens, passwords, or any HTTP headers, the SDK will automatically replace these
  values with `**REDACTED**` in the log output. Developers can disable this redaction by setting the `debug_headers` configuration property to `True`.

  ```text
  2023-03-22 21:19:21,702 [databricks.sdk][DEBUG] GET /api/2.0/clusters/list
  < 200 OK
  < {
  <   "clusters": [
  <     {
  <       "autotermination_minutes": 60,
  <       "cluster_id": "1109-115255-s1w13zjj",
  <       "cluster_name": "DEFAULT Test Cluster",
  <       ... truncated for brevity
  <     },
  <     "... (47 additional elements)"
  <   ]
  < }
  ```

  Overall, the logging capabilities provided by the Databricks SDK for Python can be a powerful tool for monitoring and troubleshooting your
  Databricks Python projects. Developers can use the various logging methods and configuration options provided by the SDK to customize
  the logging output to their specific needs.



  You can use the client-side implementation of [`dbutils`](https://docs.databricks.com/dev-tools/databricks-utils.html) by accessing `dbutils` property on the `WorkspaceClient`.
  Most of the `dbutils.fs` operations and `dbutils.secrets` are implemented natively in Python within Databricks SDK. Non-SDK implementations still require a Databricks cluster,
  that you have to specify through the `cluster_id` configuration attribute or `DATABRICKS_CLUSTER_ID` environment variable. Don't worry if cluster is not running: internally,
  Databricks SDK for Python calls `w.clusters.ensure_cluster_is_running()`.

  ```python
  from databricks.sdk import WorkspaceClient

  w = WorkspaceClient()
  dbutils = w.dbutils

  files_in_root = dbutils.fs.ls('/')
  print(f'number of files in root: {len(files_in_root)}')
  ```

  Alternatively, you can import `dbutils` from `databricks.sdk.runtime` module, but you have to make sure that all configuration is already [present in the environment variables](#default-authentication-flow):

  ```python
  from databricks.sdk.runtime import dbutils

  for secret_scope in dbutils.secrets.listScopes():
      for secret_metadata in dbutils.secrets.list(secret_scope.name):
          print(f'found {secret_metadata.key} secret in {secret_scope.name} scope')
  ```



  Databricks is actively working on stabilizing the Databricks SDK for Python's interfaces.
  API clients for all services are generated from specification files that are synchronized from the main platform.
  You are highly encouraged to pin the exact dependency version and read the [changelog](https://github.com/databricks/databricks-sdk-py/blob/main/CHANGELOG.md)
  where Databricks documents the changes. Databricks may have minor [documented](https://github.com/databricks/databricks-sdk-py/blob/main/CHANGELOG.md)
  backward-incompatible changes, such as renaming some type names to bring more consistency.


pkgId: 10d35a7d43a27738e8adbf81a9cad03606c6756ed964ad35d8e18ef6d2600dc2
name: python-databricks-sql
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Databricks SQL framework, easy to learn, fast to code, ready for production.
url: https://github.com/bernardocouto/databricks-sql
rpm_license: Apache 2-0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-sql-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Databricks SQL framework, easy to learn, fast to code, ready for production.



  ```shell
  $ pip install databricks-sql
  ```



  ```python
  from databricks_sql.client import Configuration

  CONFIGURATION = Configuration.instance(
      access_token="",
      command_directory="",
      http_path="",
      server_hostname="",
  )
  ```



  Databricks SQL usage description:





  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .delete("catalog.schema.table")
          .where("id", "994238a4-8c18-436a-8c06-29ec89c4c056")
          .execute()
      )
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .delete("catalog.schema.table")
          .where("description", "%Databricks%", operator="LIKE")
          .execute()
      )
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .execute(
              """
                  CREATE TABLE IF NOT EXISTS catalog.schema.table (
                      id STRING NOT NULL,
                      name STRING NOT NULL,
                      description STRING,
                      CONSTRAINT table_primary_key PRIMARY KEY(id)
                  ) USING DELTA
              """,
              parameters=None,
              skip_load=True,
          )
      )
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .insert("catalog.schema.table")
          .set("id", "994238a4-8c18-436a-8c06-29ec89c4c056")
          .set("name", "Name")
          .set("description", "Description")
          .execute()
      )
  ```





  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .select("catalog.schema.table")
          .fields("id", "name", "description")
          .where("name", "%Databricks%", operator="LIKE")
          .order_by("id")
          .paging(0, 10)
      )
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .select("catalog.schema.table")
          .paging(0, 10)
      )
  ```





  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .select("catalog.schema.table")
          .execute()
          .fetch_all()
      )
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .select("catalog.schema.table")
          .execute()
          .fetch_many(1)
      )
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .select("catalog.schema.table")
          .execute()
          .fetch_one()
      )
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .execute("command.sql", {"id": "994238a4-8c18-436a-8c06-29ec89c4c056"})
          .fetch_one()
      )
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .execute("SELECT id, name, description FROM catalog.schema.table WHERE id = uid=1090(lkp) gid=1090(lkp) groups=1090(lkp)s", {"id": "994238a4-8c18-436a-8c06-29ec89c4c056"})
          .fetch_one()
      )
  ```





  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .update("catalog.schema.table")
          .set("name", "New Name")
          .set("description", "New Description")
          .where("id", "994238a4-8c18-436a-8c06-29ec89c4c056")
          .execute()
      )
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .update("catalog.schema.table")
          .set("name", "New Name")
          .set("description", "New Description")
          .where_all({"id": "994238a4-8c18-436a-8c06-29ec89c4c056", "name": "Name", "description": "Description"})
          .execute()
      )
  ```





  ```sql
  select
      id,
      name,
      description
  from catalog.schema.table
  where 1 = 1
  {{#id}}
  and id = uid=1090(lkp) gid=1090(lkp) groups=1090(lkp)s
  {{/id}}
  {{#name}}
  and name like s
  {{/name}}
  ```



  ```python
  from databricks_sql.client import Database

  with Database() as connection:
      (
          connection
          .execute("command.sql", parameters={"id": "994238a4-8c18-436a-8c06-29ec89c4c056", "name": "Name"})
          .fetch_one()
      )
  ```



  This project is licensed under the terms of the [Apache License 2.0](https://github.com/bernardocouto/databricks-sql/blob/main/LICENSE).


pkgId: faa34d5583152fcaf0be89948b3a100159ed85b2575e7d36c64ea97f04159e70
name: python-databricks-sql-cli
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: A DBCLI client for Databricks SQL
url: https://pypi.org/project/databricks-sql-cli/
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-sql-cli-0.3.3-1.src.rpm
checksum_type: sha256
description:
  Databricks SQL CLI is a command line interface (CLI) for [Databricks SQL](https://databricks.com/product/databricks-sql) that can do auto-completion and syntax highlighting, and is a proud member of the dbcli community.

  ![](https://github.com/databricks/databricks-sql-cli/raw/main/dbsqlcli-demo.gif?raw=True)





  You'll need Python 3.7 or newer.

  ```bash
  python3 -m pip install databricks-sql-cli
  ```

  You can now run `dbsqlcli` from your terminal.



  To connect with SQL Endpoints `dbsqlcli` needs the host name and http path from the [connection details](https://docs.databricks.com/integrations/bi/jdbc-odbc-bi.html#get-connection-details-for-a-sql-warehouse) screen in Databricks SQL and a [personal access token](https://docs.databricks.com/dev-tools/api/latest/authentication.html#token-management). You can provide these to `dbsqlcli` as command line arguments, by setting environment variables, or by writing them into the `[credentials]` section of the `dbsqlclirc` file (see below).




  A config file is automatically created at `~/.dbsqlcli/dbsqlclirc` at first launch (run `dbsqlcli`). See the file itself for a description of all available options.




  ``` bash
  $ dbsqlcli -e 'select id, name from minifigs LIMIT 10'
  ```



  ```bash
  $ dbsqlcli -e query.sql
  ```



  ```bash
  $ dbsqlcli -e query.sql > output.csv
  ```



  ``` bash
  $ cd <directory containing dbsqlcli binary>
  $ ./dbslqcli [<database_name>]
  ```

  Run the `help;` command to see a list of shortcuts



  - Auto-completes as you type for SQL keywords as well as tables and columns in the database.
  - Syntax highlighting.
  - Smart-completion will suggest context-sensitive completion.
      - `SELECT * FROM <tab>` will only show table names.
      - `SELECT * FROM users WHERE <tab>` will only show column names.
  - Pretty prints tabular data and various table formats.
  - Some special commands. e.g. Favorite queries.
  - Alias support. Column completions will work even when table names are aliased.



  ```bash
  $ dbsqlcli --help
  Usage: dbsqlcli [OPTIONS] [DATABASE]

    A DBSQL terminal querying client with auto-completion and syntax
    highlighting.

    Examples:
      - dbsqlcli
      - dbsqlcli my_database

  Options:
    -e, --execute TEXT   Execute a command (or a file) and quit.
    --hostname TEXT      Hostname  [env var: DBSQLCLI_HOST_NAME]
    --http-path TEXT     HTTP Path  [env var: DBSQLCLI_HTTP_PATH]
    --access-token TEXT  Access Token  [env var: DBSQLCLI_ACCESS_TOKEN]
    --clirc FILE         Location of clirc file.
    --table-format TEXT  Table format used with -e option.
    --help               Show this message and exit.
  ```




  We use [Poetry](https://python-poetry.org/docs/) for development. Follow the instructions to install Poetry on your system.

  1. Clone this repository
  2. `poetry install` will install its dependencies
  3. `poetry shell` will activate the local virtual environment
  4. `python app.py` will run `dbsqlcli` incorporating any of your local changes



  Huge thanks to the maintainers of https://github.com/dbcli/athenacli upon which this project is built.



  The [DBCLI](https://github.com/dbcli) organization on Github maintains CLIs for numerous database platforms including MySQL, Postgres, and MSSQL.

  - https://github.com/dbcli/mycli
  - https://github.com/dbcli/pgcli
  - https://github.com/dbcli/mssql-cli


pkgId: cfb5c28a9116475a7e8007fd11038e149b037d658494ad196db3d6dca8529dc1
name: python-databricks-sql-connector
arch: src
version: 3.4.0
epoch: 0
release: 1
summary: Databricks SQL Connector for Python
url: https://github.com/databricks/databricks-sql-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-sql-connector-3.4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/databricks-sql-connector?style=flat-square)](https://pypi.org/project/databricks-sql-connector/)
  [![Downloads](https://pepy.tech/badge/databricks-sql-connector)](https://pepy.tech/project/databricks-sql-connector)

  The Databricks SQL Connector for Python allows you to develop Python applications that connect to Databricks clusters and SQL warehouses. It is a Thrift-based client with no dependencies on ODBC or JDBC. It conforms to the [Python DB API 2.0 specification](https://www.python.org/dev/peps/pep-0249/) and exposes a [SQLAlchemy](https://www.sqlalchemy.org/) dialect for use with tools like `pandas` and `alembic` which use SQLAlchemy to execute DDL. Use `pip install databricks-sql-connector[sqlalchemy]` to install with SQLAlchemy's dependencies. `pip install databricks-sql-connector[alembic]` will install alembic's dependencies.

  This connector uses Arrow as the data-exchange format, and supports APIs to directly fetch Arrow tables. Arrow tables are wrapped in the `ArrowQueue` class to provide a natural API to get several rows at a time.

  You are welcome to file an issue here for general use cases. You can also contact Databricks Support [here](help.databricks.com).



  Python 3.8 or above is required.



  For the latest documentation, see

  - [Databricks](https://docs.databricks.com/dev-tools/python-sql-connector.html)
  - [Azure Databricks](https://docs.microsoft.com/en-us/azure/databricks/dev-tools/python-sql-connector)



  Install the library with `pip install databricks-sql-connector`

  ```bash
  export DATABRICKS_HOST=********.databricks.com
  export DATABRICKS_HTTP_PATH=/sql/1.0/endpoints/****************
  ```

  Example usage:
  ```python
  import os
  from databricks import sql

  host = os.getenv("DATABRICKS_HOST")
  http_path = os.getenv("DATABRICKS_HTTP_PATH")

  connection = sql.connect(
    server_hostname=host,
    http_path=http_path)

  cursor = connection.cursor()
  cursor.execute('SELECT :param `p`, * FROM RANGE(10)', {"param": "foo"})
  result = cursor.fetchall()
  for row in result:
    print(row)

  cursor.close()
  connection.close()
  ```

  In the above example:
  - `server-hostname` is the Databricks instance host name.
  - `http-path` is the HTTP Path either to a Databricks SQL endpoint (e.g. /sql/1.0/endpoints/1234567890abcdef),
  or to a Databricks Runtime interactive cluster (e.g. /sql/protocolv1/o/1234567890123456/1234-123456-slid123)

  > Note: This example uses [Databricks OAuth U2M](https://docs.databricks.com/en/dev-tools/auth/oauth-u2m.html)
  > to authenticate the target Databricks user account and needs to open the browser for authentication. So it
  > can only run on the user's machine.




  See [CONTRIBUTING.md](CONTRIBUTING.md)



  [Apache License 2.0](LICENSE)


pkgId: b8e5a42e09bb03e7f50928ce0165677574095df291be11bcc95980f9af1bfc7e
name: python-databricks-sqlalchemy
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Databricks SQLAlchemy plugin for Python
url: https://github.com/databricks/databricks-sqlalchemy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-sqlalchemy-2.0.3-1.src.rpm
checksum_type: sha256
description:
  The Databricks dialect for SQLAlchemy serves as bridge between [SQLAlchemy](https://www.sqlalchemy.org/) and the Databricks SQL Python driver. A working example demonstrating usage can be found in `sqlalchemy_example.py`.




  To install the dialect and its dependencies:

  ```shell
  pip install databricks-sqlalchemy
  ```

  If you also plan to use `alembic` you can alternatively run:

  ```shell
  pip install alembic
  ```



  Every SQLAlchemy application that connects to a database needs to use an [Engine](https://docs.sqlalchemy.org/en/20/tutorial/engine.html#tutorial-engine), which you can create by passing a connection string to `create_engine`. The connection string must include these components:

  1. Host
  2. HTTP Path for a compute resource
  3. API access token
  4. Initial catalog for the connection
  5. Initial schema for the connection

  **Note: Our dialect is built and tested on workspaces with Unity Catalog enabled. Support for the `hive_metastore` catalog is untested.**

  For example:

  ```python
  import os
  from sqlalchemy import create_engine

  host = os.getenv("DATABRICKS_SERVER_HOSTNAME")
  http_path = os.getenv("DATABRICKS_HTTP_PATH")
  access_token = os.getenv("DATABRICKS_TOKEN")
  catalog = os.getenv("DATABRICKS_CATALOG")
  schema = os.getenv("DATABRICKS_SCHEMA")

  engine = create_engine(
      f"databricks://token:{access_token}@{host}?http_path={http_path}&catalog={catalog}&schema={schema}"
      )
  ```



  The [SQLAlchemy type hierarchy](https://docs.sqlalchemy.org/en/20/core/type_basics.html) contains backend-agnostic type implementations (represented in CamelCase) and backend-specific types (represented in UPPERCASE). The majority of SQLAlchemy's [CamelCase](https://docs.sqlalchemy.org/en/20/core/type_basics.html#the-camelcase-datatypes) types are supported. This means that a SQLAlchemy application using these types should "just work" with Databricks.

  |SQLAlchemy Type|Databricks SQL Type|
  |-|-|
  [`BigInteger`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.BigInteger)| [`BIGINT`](https://docs.databricks.com/en/sql/language-manual/data-types/bigint-type.html)
  [`LargeBinary`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.LargeBinary)| (not supported)|
  [`Boolean`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Boolean)| [`BOOLEAN`](https://docs.databricks.com/en/sql/language-manual/data-types/boolean-type.html)
  [`Date`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Date)| [`DATE`](https://docs.databricks.com/en/sql/language-manual/data-types/date-type.html)
  [`DateTime`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.DateTime)| [`TIMESTAMP_NTZ`](https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-ntz-type.html)|
  [`Double`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Double)| [`DOUBLE`](https://docs.databricks.com/en/sql/language-manual/data-types/double-type.html)
  [`Enum`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Enum)| (not supported)|
  [`Float`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Float)| [`FLOAT`](https://docs.databricks.com/en/sql/language-manual/data-types/float-type.html)
  [`Integer`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Integer)| [`INT`](https://docs.databricks.com/en/sql/language-manual/data-types/int-type.html)
  [`Numeric`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Numeric)| [`DECIMAL`](https://docs.databricks.com/en/sql/language-manual/data-types/decimal-type.html)|
  [`PickleType`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.PickleType)| (not supported)|
  [`SmallInteger`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.SmallInteger)| [`SMALLINT`](https://docs.databricks.com/en/sql/language-manual/data-types/smallint-type.html)
  [`String`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.String)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
  [`Text`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Text)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
  [`Time`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Time)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
  [`Unicode`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Unicode)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
  [`UnicodeText`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.UnicodeText)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
  [`Uuid`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Uuid)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)

  In addition, the dialect exposes three UPPERCASE SQLAlchemy types which are specific to Databricks:

  - [`databricks.sqlalchemy.TINYINT`](https://docs.databricks.com/en/sql/language-manual/data-types/tinyint-type.html)
  - [`databricks.sqlalchemy.TIMESTAMP`](https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-type.html)
  - [`databricks.sqlalchemy.TIMESTAMP_NTZ`](https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-ntz-type.html)




  Databricks Runtime doesn't currently support binding of binary values in SQL queries, which is a pre-requisite for this functionality in SQLAlchemy.



  Support for `CHECK` constraints is not implemented in this dialect. Support is planned for a future release.

  SQLAlchemy's `Enum()` type depends on `CHECK` constraints and is therefore not yet supported.



  Databricks Runtime provides two datetime-like types: `TIMESTAMP` which is always timezone-aware and `TIMESTAMP_NTZ` which is timezone agnostic. Both types can be imported from `databricks.sqlalchemy` and used in your models.

  The SQLAlchemy documentation indicates that `DateTime()` is not timezone-aware by default. So our dialect maps this type to `TIMESTAMP_NTZ()`. In practice, you should never need to use `TIMESTAMP_NTZ()` directly. Just use `DateTime()`.

  If you need your field to be timezone-aware, you can import `TIMESTAMP()` and use it instead.

  _Note that SQLAlchemy documentation suggests that you can declare a `DateTime()` with `timezone=True` on supported backends. However, if you do this with the Databricks dialect, the `timezone` argument will be ignored._

  ```python
  from sqlalchemy import DateTime
  from databricks.sqlalchemy import TIMESTAMP

  class SomeModel(Base):
      some_date_without_timezone  = DateTime()
      some_date_with_timezone     = TIMESTAMP()
  ```



  Databricks Runtime doesn't support length limitations for `STRING` fields. Therefore `String()` or `String(1)` or `String(255)` will all produce identical DDL. Since `Text()`, `Unicode()`, `UnicodeText()` all use the same underlying type in Databricks SQL, they will generate equivalent DDL.



  Databricks Runtime doesn't have a native time-like data type. To implement this type in SQLAlchemy, our dialect stores SQLAlchemy `Time()` values in a `STRING` field. Unlike `DateTime` above, this type can optionally support timezone awareness (since the dialect is in complete control of the strings that we write to the Delta table).

  ```python
  from sqlalchemy import Time

  class SomeModel(Base):
      time_tz     = Time(timezone=True)
      time_ntz    = Time()
  ```






  Identity and generated value support is currently limited in this dialect.

  When defining models, SQLAlchemy types can accept an [`autoincrement`](https://docs.sqlalchemy.org/en/20/core/metadata.html#sqlalchemy.schema.Column.params.autoincrement) argument. In our dialect, this argument is currently ignored. To create an auto-incrementing field in your model you can pass in an explicit [`Identity()`](https://docs.sqlalchemy.org/en/20/core/defaults.html#identity-ddl) instead.

  Furthermore, in Databricks Runtime, only `BIGINT` fields can be configured to auto-increment. So in SQLAlchemy, you must use the `BigInteger()` type.

  ```python
  from sqlalchemy import Identity, String

  class SomeModel(Base):
      id      = BigInteger(Identity())
      value   = String()
  ```

  When calling `Base.metadata.create_all()`, the executed DDL will include `GENERATED ALWAYS AS IDENTITY` for the `id` column. This is useful when using SQLAlchemy to generate tables. However, as of this writing, `Identity()` constructs are not captured when SQLAlchemy reflects a table's metadata (support for this is planned).



  `databricks-sql-connector` supports two approaches to parameterizing SQL queries: native and inline. Our SQLAlchemy 2.0 dialect always uses the native approach and is therefore limited to DBR 14.2 and above. If you are writing parameterized queries to be executed by SQLAlchemy, you must use the "named" paramstyle (`:param`). Read more about parameterization in `docs/parameters.md`.



  Use [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_sql.html) and [`pandas.read_sql`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql.html#pandas.read_sql) to write and read from Databricks SQL. These methods both accept a SQLAlchemy connection to interact with Databricks.


  ```python
  from sqlalchemy import create_engine
  import pandas as pd

  engine = create_engine("databricks://token:dapi***@***.cloud.databricks.com?http_path=***&catalog=main&schema=test")
  with engine.connect() as conn:
      
      df = pd.read_sql("some_table", conn)
  ```



  ```python
  from sqlalchemy import create_engine
  import pandas as pd

  engine = create_engine("databricks://token:dapi***@***.cloud.databricks.com?http_path=***&catalog=main&schema=test")
  squares = [(i, i * i) for i in range(100)]
  df = pd.DataFrame(data=squares,columns=['x','x_squared'])

  with engine.connect() as conn:
      
      df.to_sql('squares',conn)
  ```



  Unity Catalog workspaces in Databricks support PRIMARY KEY and FOREIGN KEY constraints. _Note that Databricks Runtime does not enforce the integrity of FOREIGN KEY constraints_. You can establish a primary key by setting `primary_key=True` when defining a column.

  When building `ForeignKey` or `ForeignKeyConstraint` objects, you must specify a `name` for the constraint.

  If your model definition requires a self-referential FOREIGN KEY constraint, you must include `use_alter=True` when defining the relationship.

  ```python
  from sqlalchemy import Table, Column, ForeignKey, BigInteger, String

  users = Table(
      "users",
      metadata_obj,
      Column("id", BigInteger, primary_key=True),
      Column("name", String(), nullable=False),
      Column("email", String()),
      Column("manager_id", ForeignKey("users.id", name="fk_users_manager_id_x_users_id", use_alter=True))
  )
  ```


pkgId: 44a9fc67eaa394adb583cce7801184b8f840ba61972a9b83e0e4bd65d61deb5d
name: python-databricks-test
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Unit testing and mocking for Databricks
url: https://github.com/microsoft/DataOps
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-test-0.0.4-1.src.rpm
checksum_type: sha256
description:
  An experimental unit test framework for Databricks notebooks.

  _This open-source project is not developed by nor affiliated with Databricks._



  ```
  pip install databricks_test
  ```



  Add a cell at the beginning of your Databricks notebook:

  ```python

  if 'dbutils' not in locals():
      import databricks_test
      databricks_test.inject_variables()
  ```

  The `if` clause causes the inner code to be skipped when run in Databricks.
  Therefore there is no need to install the `databricks_test` module on your Databricks environment.

  Add your notebook into a code project, for example using [GitHub version control in Azure Databricks](https://docs.microsoft.com/en-us/azure/databricks/notebooks/azure-devops-services-version-control).

  Set up pytest in your code project (outside of Databricks).

  Create a test case with the following structure:

  ```python
  import databricks_test

  def test_method():
      with databricks_test.session() as dbrickstest:

          
          

          
          dbrickstest.run_notebook("notebook_dir", "notebook_name_without_py_suffix")

          
          
  ```

  You can set up [mocks](https://docs.python.org/dev/library/unittest.mock.html) on `dbrickstest`, for example:

  ```python
  dbrickstest.dbutils.widgets.get.return_value = "myvalue"
  ```

  See samples below for more examples.



  * Spark context injected into Databricks notebooks: `spark`, `table`, `sql` etc.
  * PySpark with all Spark features including reading and writing to disk, UDFs and Pandas UDFs
  * Databricks Utilities (`dbutils`, `display`) with user-configurable mocks
  * Mocking connectors such as Azure Storage, S3 and SQL Data Warehouse



  * Notebook formats other than `.py` (`.ipynb`, `.dbc`) are not supported
  * Non-python cells such as `%scala` and `%sql` (those cells are skipped, as they are stored in `.py` notebooks as comments)
  * Writing directly to `/dbfs` mount on local filesystem:
    write to a local temporary file instead and use dbutils.fs.cp() to copy to DBFS, which you can intercept with a mock
  * Databricks extensions to Spark such as `spark.read.format("binaryFile")`



  Sample test case for an ETL notebook reading CSV and writing Parquet.

  ```python
  import pandas as pd
  import databricks_test
  from tempfile import TemporaryDirectory

  from pandas.testing import assert_frame_equal

  def test_etl():
      with databricks_test.session() as dbrickstest:
          with TemporaryDirectory() as tmp_dir:
              out_dir = f"{tmp_dir}/out"

              
              switch = {
                  "input": "tests/etl_input.csv",
                  "output": out_dir,
              }
              dbrickstest.dbutils.widgets.get.side_effect = lambda x: switch.get(
                  x, "")

              
              dbrickstest.run_notebook(".", "etl_notebook")

              
              resultDF = pd.read_parquet(out_dir)

          
          expectedDF = pd.read_csv("tests/etl_expected.csv")
          assert_frame_equal(expectedDF, resultDF, check_dtype=False)
  ```

  In the notebook, we pass parameters using widgets.
  This makes it easy to pass
  a local file location in tests, and a remote URL (such as Azure Storage or S3)
  in production.

  ```python



  from pyspark.sql.types import StructType, StructField
  from pyspark.sql.types import DoubleType, IntegerType
  from pyspark.sql.functions import col, pandas_udf, PandasUDFType




  if 'dbutils' not in locals():
      import databricks_test
      databricks_test.inject_variables()




  dbutils.widgets.text("input", "")
  dbutils.widgets.text("output", "")
  dbutils.widgets.text("secretscope", "")
  dbutils.widgets.text("secretname", "")
  dbutils.widgets.text("keyname", "")





  spark.conf.set(
      dbutils.widgets.get("keyname"),
      dbutils.secrets.get(
          scope=dbutils.widgets.get("secretscope"),
          key=dbutils.widgets.get("secretname")
      ),
  )




  schema = StructType(
      [
          StructField("aDouble", DoubleType(), nullable=False),
          StructField("anInteger", IntegerType(), nullable=False),
      ]
  )

  df = (
      spark.read.format("csv")
      .options(header="true", mode="FAILFAST")
      .schema(schema)
      .load(dbutils.widgets.get('input'))
  )
  display(df)



  df.count()




  @pandas_udf('integer', PandasUDFType.SCALAR)
  def square(x):
      return x * x





  (df
      .withColumn("aSquaredInteger", square(col("anInteger")))
      .write
      .parquet(dbutils.widgets.get('output'))
   )
  ```




  Sample test case mocking PySpark classes for a notebook connecting to Azure SQL Data Warehouse.

  ```python
  import databricks_test
  import pyspark
  import pyspark.sql.functions as F
  from tempfile import TemporaryDirectory
  from pandas.testing import assert_frame_equal
  import pandas as pd


  def test_sqldw(monkeypatch):
      with databricks_test.session() as dbrickstest, TemporaryDirectory() as tmp:

          out_dir = f"{tmp}/out"

          
          def mock_load(reader):
              return (
                  dbrickstest.spark
                  .range(10)
                  .withColumn("age", F.col("id") * 6)
                  .withColumn("salary", F.col("id") * 10000)
              )

          monkeypatch.setattr(
              pyspark.sql.readwriter.DataFrameReader, "load", mock_load)

          
          def mock_save(writer):
              monkeypatch.undo()
              writer.format("parquet")
              writer.save(out_dir)

          monkeypatch.setattr(
              pyspark.sql.readwriter.DataFrameWriter, "save", mock_save)

          
          dbrickstest.run_notebook(".", "sqldw_notebook")

          
          resultDF = pd.read_parquet(out_dir)

          
          expectedDF = pd.read_csv("tests/sqldw_expected.csv")
          assert_frame_equal(expectedDF, resultDF, check_dtype=False)
  ```



  Please report issues at [https://github.com/microsoft/DataOps/issues](https://github.com/microsoft/DataOps/issues).


pkgId: 31ea4fed351b6948a8085b1797413d16cf5411d54c1a4caa3f56a7ae9f08db7e
name: python-databricks-utils
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Ease-of-use utility tools for databricks notebooks.
url: https://github.com/e2fyi/databricks-utils
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricks-utils-0.0.7-1.src.rpm
checksum_type: sha256
description:
  [![Python version](https://img.shields.io/badge/python-3.6-blue.svg)](https://shields.io/)
  [![Pyspark version](https://img.shields.io/badge/pyspark-2.3.1-blue.svg)](https://shields.io/)
  [![Build Status](https://travis-ci.org/e2fyi/databricks-utils.svg?branch=master)](https://travis-ci.org/e2fyi/databricks-utils)

  `databricks-utils` is a python package that provide several utility classes/func
  that improve ease-of-use in databricks notebook.


  ```bash
  pip install databricks-utils
  ```


  - `S3Bucket` class to easily interact with a [S3 bucket](https://aws.amazon.com/s3/) via [`dbfs`](https://docs.databricks.com/user-guide/dbfs-databricks-file-system.html) and databricks spark.

  - `vega_embed` to render charts from [Vega](https://vega.github.io/vega/) and [Vega-Lite](https://vega.github.io/vega-lite/) specifications.


  API documentation can be found at [https://e2fyi.github.io/databricks-utils/](https://e2fyi.github.io/databricks-utils/).



  **S3Bucket**
  ```python
  import json
  from databricks_utils.aws import S3Bucket



  S3Bucket.attach_dbutils(dbutils)


  bucket = (S3Bucket("somebucketname", "SOMEACCESSKEY", "SOMESECRETKEY")
            .allow_spark(sc) # local spark context
            .mount("somebucketname")) # mount location name (resolves as `/mnt/somebucketname`)


  bucket.ls("resource/")


  data = json.load(open(bucket.local("resource/somefile.json", "r")))


  dataframe = spark.read.parquet(bucket.s3("resource/somedf.parquet"))


  bucket.umount()
  ```

  **Vega**
  [Vega](https://vega.github.io/vega/) and [Vega-Lite](https://vega.github.io/vega-lite/)
  are high-level grammars of interactive graphics. They provide concise JSON
  syntax for rapidly generating visualizations to support analysis.

  ```python
  from databricks_utils.vega import vega_embed


  spec = {
    "data": {
      "values": [
        {"a": "A","b": 28}, {"a": "B","b": 55}, {"a": "C","b": 43},
        {"a": "D","b": 91}, {"a": "E","b": 81}, {"a": "F","b": 53},
        {"a": "G","b": 19}, {"a": "H","b": 87}, {"a": "I","b": 52}
      ]
    },
    "mark": "bar",
    "encoding": {
      "x": {"field": "a", "type": "ordinal"},
      "y": {"field": "b", "type": "quantitative"}
    }
  }


  displayHTML(vega_embed(spec=spec))
  ```


  ```bash

  . add_tag.sh <VERSION>
  ```


pkgId: 5a77517a7682752a15a5c5acdfc6a9694c3d9735241fb6f716e24d58b31987d7
name: python-databricksapi
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: Python Databricks API wrapper using requests module
url: https://github.com/angel-hernandez91/databricks_api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-databricksapi-1.1.8-1.src.rpm
checksum_type: sha256
description:
  *This package is a Python Implementation of the [Databricks API](https://docs.databricks.com/api/latest/index.html) for structured and programmatic use. This Python implementation requires that your Databricks API Token be saved as an environment variable in your system:* `export DATABRICKS_TOKEN=MY_DATABRICKS_TOKEN` in OSX / Linux. Or in Windows by searching for System Environment Variables in the Start Menu and adding it in the editor. For details see this [guide](https://superuser.com/questions/949560/how-do-i-set-system-environment-variables-in-windows-10).


  *Tokens can now be passed when a particular class is instantiated. E.g.:*

  ```python
  from databricksapi import Workspace
  url = 'https://my-databricks-instance.com'
  token = 'dapiXXXXXXXXXXXXX'
  ws = Workspace(url, token)

  ```


  You can either use `pip install databricksapi` to install it globally, or you can clone the repository. Please note that only compatability with Python 3.7+ is guaranteed.


  * Token
  * Secrets
  * Clusters
  * SCIM (Experimental)
  * Jobs
  * DBFS
  * Groups
  * Instance Profiles
  * Libraries
  * Workspace


  The modules above can be imported as follows
  ```python
  from databricksapi import Token, Jobs, DBFS
  url = 'https://url.for.databricks.net'

  token_instance = Token(url)
  jobs_instance = Jobs(url)
  ```


  The Token API allows any user to create, list, and revoke tokens that can be used to authenticate and access Databricks REST APIs. Initial authentication to this API is the same as for all of the Databricks API endpoints.


  1. createToken(*lifetime_seconds*, *comment*)
  2. listTokens()
  3. revokeToken(*token_id*)


  Create and return a token.
  ```python
  url = 'https://url.for.databricks.net'
  db_api = Token(url)

  db_api.createToken(600, 'Test token')
  ```


  List all Token IDs in your Databricks Environment.
  ```python
  url = 'https://url.for.databricks.net'
  db_api = Token(url)

  db_api.listTokens()
  ```


  Revoke an active Databricks token.
  ```python
  url = 'https://url.for.databricks.net'
  db_api = Token(url)


  db_api.revokeToken('5715498424f15ee0213be729257b53fc35a47d5953e3bdfd8ed22a0b93b339f4')
  ```


  The Secrets API allows you to manage secrets, secret scopes, and access permissions.


  1. createSecretScope(*scope*, *initial_manage_principal*)
  2. deleteSecretScope(*scope*)
  3. listSecretScopes()
  4. putSeceret(*value*, *value_type*, *scope*, *key*)
  5. deleteSecret(*scope*, *key*)
  6. listSecrets(*scope*)
  7. putSecretACL(*scope*, *principal*, *permission*)
  8. deleteSecretACL(*scope*, *principal*)
  9. getSecretACL(*scope, *principal*)
  10. listSecretACL(*scope*, *principal*)


  Creates a new secret scope.

  The scope name must consist of alphanumeric characters, dashes, underscores, and periods, and may not exceed 128 characters. The maximum number of scopes in a workspace is 100.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  initial_manage_princial = 'users'
  db_api.createSecretScope(scope, initial_manage_princial)
  ```



  Delete a secret scope.
  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  db_api.deleteSecretScope(scope)
  ```


  List all secret scopes in the workspace

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  db_api.listSecretScopes()
  ```


  Inserts a secret under the provided scope with the given name. If a secret already exists with the same name, this command overwrites the existing secret’s value. The server encrypts the secret using the secret scope’s encryption settings before storing it. You must have WRITE or MANAGE permission on the secret scope.

  The `value_type` parameter can either be set to `string` or `bytes` depending on the type fo value the user passes in.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)


  value = 'BeepBoop'
  value_type = 'string'
  scope = 'SomeSecretScope'
  key = 'uniqueScopekey'

  db_api.putSecret(value, value_type, scope, key)
  ```


  Deletes the secret stored in this secret scope. You must have WRITE or MANAGE permission on the secret scope.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  key = 'uniqueScopekey'

  db_api.deleteSecret(scope, key)
  ```


  Lists the secret keys that are stored at this scope. This is a metadata-only operation; secret data cannot be retrieved using this API. Users need READ permission to make this call.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'

  db_api.listSecrets(scope)
  ```


  Creates or overwrites the ACL associated with the given principal (user or group) on the specified scope point. In general, a user or group will use the most powerful permission available to them

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  prinicpal = 'users'
  permission = 'READ'

  db_api.putSecretACL(scope, principal, permission)
  ```


  Deletes the given ACL on the given scope.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  prinicpal = 'users'

  db_api.deleteSecretACL(scope, principal)
  ```


  Describes the details about the given ACL, such as the group and permission.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  prinicpal = 'users'

  db_api.getSecretACL(scope, principal)
  ```


  Lists the ACLs set on the given scope.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  prinicpal = 'users'

  db_api.listSecretACL(scope, principal)
  ```


  The Clusters API allows you to create, start, edit, list, terminate, and delete clusters via the API. The maximum allowed size of a request to the Clusters API is 10MB.


  1. createCluster(*worker*, *worker_type*, *cluster_name*, *spark_version*, *cluster_log_conf*, *node_type_id*, *driver_node_type_id=None*, *spark_conf=None*, *aws_attributes=None*, *ssh_public_keys=None*, *custom_tags=None*, *init_scripts=None*, *spark_env_vars=None*, *autotermination_minutes=None*, *enable_elastic_disk=None*)
  2. editCluster(*worker*, *worker_type*, *cluster_name*, *spark_version*, *cluster_log_conf*, *node_type_id*, *driver_node_type_id=None*, *spark_conf=None*, *aws_attributes=None*, *ssh_public_keys=None*, *custom_tags=None*, *init_scripts=None*, *spark_env_vars=None*, *autotermination_minutes=None*, *enable_elastic_disk=None*)
  3. startCluster(*cluster_id*)
  4. restartCluster(*cluster_id*)
  5. resizeCluster(*cluster_id*, *worker*, *worker_type*)
  6. terminateCluster(*cluster_id*)
  7. deleteCluster(*cluster_id*)
  8. getCluster(*cluster_id*)
  9. pinCluster(*cluster_id*)
  10. unpinCluster(*cluster_id*)
  11. listClusters()
  12. listNodeTypes()
  13. listZones()
  14. getSparkVersions()
  15. getClusterEvents(*cluster_id*, *order='DESC'*, *start_time=None*, *end_time=None*, *event_types=None*, *offset=None*, *limit=None*)



  Creates a new Spark cluster. This method acquires new instances from the cloud provider if necessary. This method is asynchronous; the returned cluster_id can be used to poll the cluster state. When this method returns, the cluster is in a PENDING state. The cluster is usable once it enters a RUNNING state.

  The `worker_type` can be either `workers` or `autoscale`. If a `autoscale` is set, then the `min_workers` and `max_workers` must be specified.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  worker = 25
  worker_type = 'workers'
  cluster_name = 'TestCluster'
  spark_version = '4.0.x-scala2.11'
  cluster_log_conf = '/dbfs/log/path'
  node_type_id = 'i3.xlarge'

  db_api.createCluster(worker=worker, worker_type=worker_type, cluster_name=cluster_name, spark_version=spark_version, cluster_log_conf=cluster_log_conf, node_type_id=node_type_id)
  ```



  Edit an existings clusters configuration.

  The `worker_type` can be either `workers` or `autoscale`. If a `autoscale` is set, then the `min_workers` and `max_workers` must be specified.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  worker = 35
  worker_type = 'workers'
  cluster_name = 'TestCluster'
  spark_version = '4.0.x-scala2.11'
  cluster_log_conf = '/dbfs/new/log/path'
  node_type_id = 'i5.xlarge'

  db_api.editCluster(worker=worker, worker_type=worker_type, cluster_name=cluster_name, spark_version=spark_version, cluster_log_conf=cluster_log_conf, node_type_id=node_type_id)
  ```


  Starts a terminated Spark cluster given its ID.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'
  db_api.startCluster(cluster_id)
  ```


  Restarts a Spark cluster given its id. If the cluster is not in a RUNNING state, nothing will happen.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'
  db_api.restartCluster(cluster_id)
  ```


  Resizes a cluster to have a desired number of workers. This will fail unless the cluster is in a RUNNING state.

  The parameter `worker_type` can be one of `workers` or `autoscale`.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'
  workers = 30

  db_api.resizeCluster(cluster_id, workers, worker_type='workers')
  ```


  Terminates a Spark cluster given its id. The cluster is removed asynchronously. Once the termination has completed, the cluster will be in a TERMINATED state. If the cluster is already in a TERMINATING or TERMINATED state, nothing will happen.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.terminateCluster(cluster_id)
  ```


  Permanently deletes a Spark cluster. If the cluster is running, it is terminated and its resources are asynchronously removed. If the cluster is terminated, then it is immediately removed.

  You cannot perform any action on a permanently deleted cluster and a permanently deleted cluster is no longer returned in the cluster list.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.deleteCluster(cluster_id)
  ```


  Returns information about all pinned clusters, currently active clusters, up to 70 of the most recently terminated interactive clusters in the past 30 days, and up to 30 of the most recently terminated job clusters in the past 30 days.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.getCluster(cluster_id)
  ```



  Pinning a cluster ensures that the cluster is always returned by the List API. Pinning a cluster that is already pinned has no effect.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.pinCluster(cluster_id)
  ```


  Unpinning a cluster will allow the cluster to eventually be removed from the list returned by the List API. Unpinning a cluster that is not pinned has no effect.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.unpinCluster(cluster_id)
  ```


  Retrieves the information for a cluster given its identifier. Clusters can be described while they are running, or up to 30 days after they are terminated.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  db_api.listClusters()
  ```


  Returns a list of supported Spark node types. These node types can be used to launch a cluster.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  db_api.listNodeTypes()
  ```


  Returns a list of availability zones where clusters can be created in (ex: us-west-2a). These zones can be used to launch a cluster.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  db_api.listZones()
  ```


  Returns the list of available Spark versions. These versions can be used to launch a cluster.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  db_api.getSparkVersions()
  ```


  Retrieves a list of events about the activity of a cluster. This API is paginated. If there are more events to read, the response includes all the parameters necessary to request the next page of events.



  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.getClusterEvents(cluster_id)
  ```


  The Jobs API allows you to create, edit, and delete jobs via the API. The maximum allowed size of a request to the Jobs API is 10MB.


  1. createJob(*cluster*, *cluster_type*, *task*, *task_type*, *name*, *libraries=None*, *email_notications=None*, *timeout_seconds=None*, *max_retries=None*, *min_retry_interval_millis=None*, *retry_on_timeout=None*,*schedule=None*, *max_concurrent_runs=None*)
  2. listJobs()
  3. deleteJob(*job_id*)
  4. batchDelete(*\*args*)
  5. getJob(*job_id*)
  6. resetJob(*job_id*, *new_settings*)
  7. runJob(*job_id*, *job_type*, *params*)
  8. runsSubmit(*run_name*, *cluster*, *task*, *cluster_type*, *task_type*, *libraries=None*, *timeout_seconds=None*)
  9. runsList(*run*, *run_type*, *job_id*, *offset*, *limit*)
  10. runsGet(*run_id*)
  11. runsExport(*run_id*, *views_to_export*)
  12. runsCancel(*run_id*)
  13. runsGetOutput(*run_id*)
  14. runsDelete(*run_id*) 


  The `cluster_type` parameter can be one of `existing` or `new`.
  The `task_type` parameter must be one of `notebook`, `jar`, `submit`, or `python`.

  All other parameters are documented in the Databricks Rest API.


  Takes in a comma separated list of Job IDs to be deleted. This method is a wrapper around the `deleteJob` method.


  The `job_type` parameter must be one of `notebook`, `jar`, `submit` or `python`.


  The `cluster_type` parameter can be one of `existing` or `new`.


  The `run_type` parameter must be one of `completed` or `active`.


  The DBFS API is a Databricks API that makes it simple to interact with various data sources without having to include your credentials every time you read a file.


  1. addBlock(*data*, *handle*)
  2. closeStream(*handle*)
  3. createFile(*path*, *overwrite*)
  4. deleteFile(*path*, *recursive*)
  5. getStatus(*path*)
  6. listFiles(*path*)
  7. makeDirs(*path*)
  8. moveFiles(*source_path*, *target_path*)
  9. putFiles(*path*, *overwrite*, *files*, *contents=None*)
  10. readFiles(*path*, *offset*, *length*)


  The Groups API allows you to manage groups of users via the API. You must be a Databricks administrator to invoke this API.


  1. addMember(*parent_name*, *name*, *name_type*)
  2. createGroup(*group_name*)
  3. listGroupMembers(*group_name*, *return_type='json'*)
  4. listGroups()
  5. listParents(*name*, *name_type*)
  6. removeMember(*name*, *parent_name*, *name_type*)
  7. deleteGroup(*group_name*)


  The default `return_type` can be one of `json` or `list`, by default the paramter is set to `json`. This is provide to simplify pulling usernames from the default return time which can be cumbersome.


  The `name_type` parameter must be one of `user` or `group`.


  The `name_type` parameter must be one of `user` or `group`.


  The Instance Profiles API allows admins to add, list, and remove instance profiles that users can launch clusters with. Regular users can list the instance profiles available to them.


  1. addProfile(*profile_arn*, *skip_validation=None*)
  2. listProfiles()
  3. removeProfile()


  The Libraries API allows you to install and uninstall libraries and get the status of libraries on a cluster via the API.


  1. allClusterStatuses(*status*)
  2. clusterStatus(*cluster_id*)
  3. installLibrary(*cluster_id*, *libraries*)
  4. uninstallLibrary(*cluster_id*, *libraries*)


  1. deleteWorkspace(*path*, *recursive*)
  2. exportWorkspace(*path*, *export_format*, *direct_download*)
  3. getWorkspaceStatus(*path*)
  4. importWorkspace(*path*, *export_format*, *language*, *content*, *overwrite*)
  5. listWorkspace(*path*)
  6. mkdirsWorkspace(*path*)


