# packages

pkgId: 23466555ba828240eb953da5c08debd707450cc409578af92b904c9a30fe2c51
name: python-fpbase-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for fpbase
url: https://pypi.org/project/fpbase/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fpbase-0.1.2-1.src.rpm
location_href: Packages/python-fpbase-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/pypi/l/fpbase.svg?color=green)](https://github.com/tlambert03/fpbasepy/raw/main/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/fpbase.svg?color=green)](https://pypi.org/project/fpbase)
  [![Python Version](https://img.shields.io/pypi/pyversions/fpbase.svg?color=green)](https://python.org)
  [![CI](https://github.com/tlambert03/fpbasepy/actions/workflows/ci.yml/badge.svg)](https://github.com/tlambert03/fpbasepy/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/tlambert03/fpbasepy/branch/main/graph/badge.svg)](https://codecov.io/gh/tlambert03/fpbasepy)

  Python wrapper for FPBase.org GraphQL API.

  See <https://www.fpbase.org/graphql> for an interactive playground and full documentation on the graphql schema
  (click the little book icon on the top left corner).



  ```sh
  pip install fpbase
  ```



  See all response model types in `fpbase.models`.



  * `fpbase.get_fluorophore`  (can return either protein or dye)
  * `fpbase.get_protein` (will only return proteins)
  * `fpbase.get_microscope`
  * `fpbase.get_filter`
  * `fpbase.get_light_source`
  * `fpbase.get_camera`



  * `fpbase.list_fluorophores`  (includes both proteins and dyes)
  * `fpbase.list_proteins`
  * `fpbase.list_dyes`
  * `fpbase.list_microscopes`
  * `fpbase.list_filters`
  * `fpbase.list_light_sources`
  * `fpbase.list_cameras`



  * `fpbase.graphql_query` : Send generic GraphQL query to FPbase (see <https://www.fpbase.org/graphql> for full documentation on the graphql schema and an interactive playground)



  ```python
  import fpbase

  fpbase.get_fluorophore("mCherry")


  ```

  <details>

  <summary>output</summary>

  ```python
  Protein(
      name='mCherry',
      id='ZERB6',
      default_state=State(
          id=336,
          name='mCherry',
          exMax=587.0,
          emMax=610.0,
          emhex='#f70000',
          exhex='#ff4600',
          ext_coeff=72000.0,
          qy=0.22,
          spectra=[
              Spectrum(id=79, subtype='EX', owner_filter=None, owner_camera=None, owner_light=None),
              Spectrum(id=80, subtype='EM', owner_filter=None, owner_camera=None, owner_light=None),
              Spectrum(id=158, subtype='A_2P', owner_filter=None, owner_camera=None, owner_light=None)
          ],
          lifetime=1.4
      ),
      seq='MVSKGEEDNMAIIKEFMRFKVHMEGSVNGHEFEIEGEGEGRPYEGTQTAKLKVTKGGPLPFAWDILSPQFMYGSKAYVKHPADIPDYLKLSFPEGFKWERVMNFEDGGVVTVTQDSSLQDGEFIYKVKLRGTNFPSDGPVMQKKTMGWEASSERMYPEDGALKGEIKQRLKLKDGGHYDAEVKTTYKAKKPVQLPGAYNVNIKLDITSHNEDYTIVEQYERAEGRHSTGGMDELYK',
      pdb=['2H5Q'],
      genbank='AAV52164',
      uniprot='X5DSL3',
      agg=<Olig.MONOMER: 'M'>,
      switch_type=<SwitchType.BASIC: 'B'>,
      primary_reference=Reference(doi='10.1038/nbt1037', url='https://doi.org/10.1038/nbt1037'),
      references=[
          Reference(doi='10.1038/nbt1037', url='https://doi.org/10.1038/nbt1037'),
          Reference(doi='10.1021/bi060773l', url='https://doi.org/10.1021/bi060773l'),
          Reference(doi='10.1038/nmeth1062', url='https://doi.org/10.1038/nmeth1062'),
          Reference(doi='10.1038/nmeth.1596', url='https://doi.org/10.1038/nmeth.1596'),
          Reference(doi='10.1038/nmeth.1955', url='https://doi.org/10.1038/nmeth.1955'),
          Reference(doi='10.1091/mbc.e16-01-0063', url='https://doi.org/10.1091/mbc.e16-01-0063'),
          Reference(doi='10.1038/s41598-017-12212-x', url='https://doi.org/10.1038/s41598-017-12212-x'),
          Reference(doi='10.1038/s41598-018-28858-0', url='https://doi.org/10.1038/s41598-018-28858-0'),
          Reference(doi='10.1002/pld3.112', url='https://doi.org/10.1002/pld3.112'),
          Reference(doi='10.1371/journal.pone.0219886', url='https://doi.org/10.1371/journal.pone.0219886'),
          Reference(doi='10.1073/pnas.2017379117', url='https://doi.org/10.1073/pnas.2017379117'),
          Reference(doi='10.1038/s41467-023-40647-6', url='https://doi.org/10.1038/s41467-023-40647-6')
      ]
  )
  ```

  </details>

  ```python
  fpbase.get_fluorophore("DAPI")
  ```

  <details>

  <summary>output</summary>

  ```python
  Fluorophore(
      name='DAPI',
      id='15',
      default_state=State(
          id=15,
          name='DAPI',
          exMax=359.0,
          emMax=461.0,
          emhex='',
          exhex='',
          ext_coeff=None,
          qy=None,
          spectra=[
              Spectrum(id=7754, subtype='AB', owner_filter=None, owner_camera=None, owner_light=None),
              Spectrum(id=222, subtype='EX', owner_filter=None, owner_camera=None, owner_light=None),
              Spectrum(id=223, subtype='EM', owner_filter=None, owner_camera=None, owner_light=None)
          ],
          lifetime=None
      )
  )
  ```

  </details>

  ```python

  fpbase.get_microscope("i6WL2W")
  ```

  <details>

  <summary>output</summary>

  ```python
  Microscope(
      id='i6WL2WdgcDMgJYtPrpZcaJ',
      name='Example Widefield (Sedat)',
      opticalConfigs=[
          OpticalConfig(
              name='Widefield Blue',
              filters=[
                  FilterPlacement(
                      path='EX',
                      filter=Filter(
                          id=52,
                          name='Chroma ET395/25x',
                          spectrum=Spectrum(id=375, subtype='BX', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='BS',
                      filter=Filter(
                          id=10,
                          name='Chroma T425lpxr',
                          spectrum=Spectrum(id=333, subtype='LP', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='EM',
                      filter=Filter(
                          id=47,
                          name='Chroma ET460/50m',
                          spectrum=Spectrum(id=370, subtype='BM', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  )
              ],
              camera=Camera(
                  id=4,
                  name='Andor Zyla 4.2 PLUS',
                  spectrum=Spectrum(id=1328, subtype='QE', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              light=LightSource(
                  id=9,
                  name='SOLA 395',
                  spectrum=Spectrum(id=394, subtype='PD', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              laser=None
          ),
          OpticalConfig(
              name='Widefield Dual FRET',
              filters=[
                  FilterPlacement(
                      path='EX',
                      filter=Filter(
                          id=63,
                          name='Lumencor 470/24x',
                          spectrum=Spectrum(id=399, subtype='BX', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='BS',
                      filter=Filter(
                          id=62,
                          name='Chroma 59022bs',
                          spectrum=Spectrum(id=385, subtype='BS', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='EM',
                      filter=Filter(
                          id=689,
                          name='Semrock FF02-641/75',
                          spectrum=Spectrum(id=1025, subtype='BP', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  )
              ],
              camera=Camera(
                  id=4,
                  name='Andor Zyla 4.2 PLUS',
                  spectrum=Spectrum(id=1328, subtype='QE', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              light=LightSource(
                  id=9,
                  name='SOLA 395',
                  spectrum=Spectrum(id=394, subtype='PD', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              laser=None
          ),
          OpticalConfig(
              name='Widefield Dual Green',
              filters=[
                  FilterPlacement(
                      path='EX',
                      filter=Filter(
                          id=63,
                          name='Lumencor 470/24x',
                          spectrum=Spectrum(id=399, subtype='BX', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='BS',
                      filter=Filter(
                          id=62,
                          name='Chroma 59022bs',
                          spectrum=Spectrum(id=385, subtype='BS', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='EM',
                      filter=Filter(
                          id=569,
                          name='Semrock FF03-525/50',
                          spectrum=Spectrum(id=905, subtype='BP', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  )
              ],
              camera=Camera(
                  id=4,
                  name='Andor Zyla 4.2 PLUS',
                  spectrum=Spectrum(id=1328, subtype='QE', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              light=LightSource(
                  id=9,
                  name='SOLA 395',
                  spectrum=Spectrum(id=394, subtype='PD', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              laser=None
          ),
          OpticalConfig(
              name='Widefield Dual Red',
              filters=[
                  FilterPlacement(
                      path='EX',
                      filter=Filter(
                          id=67,
                          name='Lumencor 575/25x',
                          spectrum=Spectrum(id=403, subtype='BX', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='BS',
                      filter=Filter(
                          id=62,
                          name='Chroma 59022bs',
                          spectrum=Spectrum(id=385, subtype='BS', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='EM',
                      filter=Filter(
                          id=689,
                          name='Semrock FF02-641/75',
                          spectrum=Spectrum(id=1025, subtype='BP', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  )
              ],
              camera=Camera(
                  id=4,
                  name='Andor Zyla 4.2 PLUS',
                  spectrum=Spectrum(id=1328, subtype='QE', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              light=LightSource(
                  id=9,
                  name='SOLA 395',
                  spectrum=Spectrum(id=394, subtype='PD', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              laser=None
          ),
          OpticalConfig(
              name='Widefield Far-Red',
              filters=[
                  FilterPlacement(
                      path='EX',
                      filter=Filter(
                          id=445,
                          name='Chroma ET640/30x',
                          spectrum=Spectrum(id=781, subtype='BX', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='BS',
                      filter=Filter(
                          id=6,
                          name='Chroma T660lpxr',
                          spectrum=Spectrum(id=329, subtype='LP', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='EM',
                      filter=Filter(
                          id=719,
                          name='Semrock FF01-698/70',
                          spectrum=Spectrum(id=1055, subtype='BP', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  )
              ],
              camera=Camera(
                  id=4,
                  name='Andor Zyla 4.2 PLUS',
                  spectrum=Spectrum(id=1328, subtype='QE', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              light=LightSource(
                  id=9,
                  name='SOLA 395',
                  spectrum=Spectrum(id=394, subtype='PD', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              laser=None
          ),
          OpticalConfig(
              name='Widefield Triple Cyan',
              filters=[
                  FilterPlacement(
                      path='EX',
                      filter=Filter(
                          id=79,
                          name='Lumencor 440/20x',
                          spectrum=Spectrum(id=415, subtype='BX', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='BS',
                      filter=Filter(
                          id=60,
                          name='Chroma 69008bs',
                          spectrum=Spectrum(id=383, subtype='BS', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='EM',
                      filter=Filter(
                          id=46,
                          name='Chroma ET470/24m',
                          spectrum=Spectrum(id=369, subtype='BM', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  )
              ],
              camera=Camera(
                  id=4,
                  name='Andor Zyla 4.2 PLUS',
                  spectrum=Spectrum(id=1328, subtype='QE', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              light=LightSource(
                  id=9,
                  name='SOLA 395',
                  spectrum=Spectrum(id=394, subtype='PD', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              laser=None
          ),
          OpticalConfig(
              name='Widefield Triple FRET',
              filters=[
                  FilterPlacement(
                      path='EX',
                      filter=Filter(
                          id=79,
                          name='Lumencor 440/20x',
                          spectrum=Spectrum(id=415, subtype='BX', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='BS',
                      filter=Filter(
                          id=60,
                          name='Chroma 69008bs',
                          spectrum=Spectrum(id=383, subtype='BS', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='EM',
                      filter=Filter(
                          id=36,
                          name='Chroma ET535/30m',
                          spectrum=Spectrum(id=359, subtype='BM', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  )
              ],
              camera=Camera(
                  id=4,
                  name='Andor Zyla 4.2 PLUS',
                  spectrum=Spectrum(id=1328, subtype='QE', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              light=LightSource(
                  id=9,
                  name='SOLA 395',
                  spectrum=Spectrum(id=394, subtype='PD', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              laser=None
          ),
          OpticalConfig(
              name='Widefield Triple Red',
              filters=[
                  FilterPlacement(
                      path='EX',
                      filter=Filter(
                          id=67,
                          name='Lumencor 575/25x',
                          spectrum=Spectrum(id=403, subtype='BX', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='BS',
                      filter=Filter(
                          id=60,
                          name='Chroma 69008bs',
                          spectrum=Spectrum(id=383, subtype='BS', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='EM',
                      filter=Filter(
                          id=689,
                          name='Semrock FF02-641/75',
                          spectrum=Spectrum(id=1025, subtype='BP', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  )
              ],
              camera=Camera(
                  id=4,
                  name='Andor Zyla 4.2 PLUS',
                  spectrum=Spectrum(id=1328, subtype='QE', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              light=LightSource(
                  id=9,
                  name='SOLA 395',
                  spectrum=Spectrum(id=394, subtype='PD', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              laser=None
          ),
          OpticalConfig(
              name='Widefield Triple Yellow',
              filters=[
                  FilterPlacement(
                      path='EX',
                      filter=Filter(
                          id=41,
                          name='Chroma ET500/20x',
                          spectrum=Spectrum(id=364, subtype='BX', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='BS',
                      filter=Filter(
                          id=60,
                          name='Chroma 69008bs',
                          spectrum=Spectrum(id=383, subtype='BS', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  ),
                  FilterPlacement(
                      path='EM',
                      filter=Filter(
                          id=36,
                          name='Chroma ET535/30m',
                          spectrum=Spectrum(id=359, subtype='BM', owner_filter=None, owner_camera=None, owner_light=None),
                          manufacturer='',
                          bandcenter=None,
                          bandwidth=None,
                          edge=None
                      ),
                      reflects=False
                  )
              ],
              camera=Camera(
                  id=4,
                  name='Andor Zyla 4.2 PLUS',
                  spectrum=Spectrum(id=1328, subtype='QE', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              light=LightSource(
                  id=9,
                  name='SOLA 395',
                  spectrum=Spectrum(id=394, subtype='PD', owner_filter=None, owner_camera=None, owner_light=None),
                  manufacturer=''
              ),
              laser=None
          )
      ]
  )
  ```

  </details>


pkgId: 7685c7dba70b7d6fbe07f6e062f3ca73fb8d06ca252a94d72f267ba715be06ef
name: python-fpkws-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for fpkws
url: https://pypi.org/project/fpkws/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fpkws-0.0.4-1.src.rpm
location_href: Packages/python-fpkws-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  A Keyword Spotting model.


  - spotting keywords in audio files.
  - Lightweight and easy to use.


  ```bash
  pip install fankws


pkgId: c8fcdb1c8fb3f9d1d6a756b1544cd83c5ce79c47e4942990521736039b6ccbc2
name: python-fprime-gds-help
arch: noarch
version: 3.5.1
epoch: 0
release: 1
summary: Development documents and examples for fprime-gds
url: https://fprime.jpl.nasa.gov
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fprime-gds-3.5.1-1.src.rpm
location_href: Packages/python-fprime-gds-help-3.5.1-1.noarch.rpm
checksum_type: sha256
description:
  **Note:** This README describes GDS internals. Refer to the [user's guide](https://nasa.github.io/fprime/UsersGuide/gds/gds-introduction.html) for instructions on how to use the GDS.

  Issues should be reported here: [File an issue](https://github.com/nasa/fprime/issues/new/choose)


  The GDS consists of a collection of classes and tools that provide an interface for fprime
  deployments, allowing users to view telemetry and events and send commands.

  The GDS HTML GUI is an almost completely rewritten version of the F´ GSE UI, our historical
  ground system that has been deprecated due to its Python 2 requirement.

  The GDS was designed to be adaptable, easily understandable, and easily expandable. To this end, it
  is built using publisher/subscriber relationships.

  The diagram below shows the basic layout of the GDS. Data from the F´ deployment first enters the
  GDS at the TCP client. Each packet is then passed directly to the distributor which is responsible
  for parsing the packets in to data messages and sending on each message type (currently only events,
  channels, and packetized telemetry are supported) to decoders registered for that type. The decoder
  is responsible for turning that data message into a data object which it passes along to all
  consumers registered to it. These consumers could be anything, but in the GDS they are GUI panels
  that display the data. For outgoing data, the structure is similar. Currently, commands are the only
  output data type included. Command data objects are created in the command panel and then sent to
  the command encoder registered to that panel. Encoders take a data object and turn it into binary
  data that can be sent to the F´ deployment. The binary data is then passed to the TCP client
  which is registered to the encoder. Finally, the TCP client send the data back to the TCP server and
  the F´ deployment. ![The layout of the GDS](https://github.com/nasa/fprime/blob/devel/docs/UsersGuide/media/gds_layout.jpg)

  All of these objects are created and registered to other objects when the GDS
  is initialized. Thus, all of the structure of the GDS is created in one place,
  and can be easily modified.


  The GDS was designed to have flexible configurations of consumers for its various data decoders.
  This has been used to support several additional tools.


  The standard pipeline can be thought of as a Python helper-layer to instantiate the GDS and connect
  to an F´ deployment. The pipeline provides event, telemetry and command histories, sending
  commands and registering consumers to the GDS decoders. The Standard Pipeline can be found
  [here](src/fprime_gds/common/pipeline/standard.py).


  The Integration Test API is a tool that provides the ability to write integration-level tests for an
  F´ deployment using the GDS. The tool provides history searches/asserts, command sending, a
  detailed test log, sub-histories and convenient access to GDS data objects. The test API comes with
  separate [documentation](https://github.com/nasa/fprime/blob/master/docs/UsersGuide/dev/testAPI/markdown/contents.md) and its own [user
  guide](https://github.com/nasa/fprime/blob/master/docs/UsersGuide/dev/testAPI/user_guide.md) and is built on top of the Standard Pipeline.



  A guide for how to use the GDS is available in the [fprime documentation](https://nasa.github.io/fprime/UsersGuide/gds/gds-introduction.html)


  The GDS back end is composed of several different data processing units. For
  most of the units described below, a base class describes the interface and
  subclasses implement the interface for specific data types (such as events,
  channels, etc).

  To expand the GDS to accept more data types or have additional features, new classes
  can be written and registered into the existing structure.


  The TCP client is simply a passthrough for data coming from the TCP Server and
  the F´ Distribution. The client handles all the socket connection overhead and
  passes un-parsed data onto all objects registered with it.


  The distributer is responsible for taking in raw binary data, parsing off the
  length and descriptor, and then passing the data to all decoders registered to
  that descriptor. Descriptor types include events, channels, packets, etc (a full
  enumeration can be found in (src/utils/data_desc_type.py). The binary data that
  the descriptor receives should be of the form:

  | Length (4 bytes) | Type Descriptor (4 bytes) | Message Data |
  | ---------------- | ------------------------- | ------------ |

  The distributor should then pass only the message data along to the decoders.


  For each general data type (channel, event, etc) there is a template type.
  Instances of these classes hold information about specific channels or event
  types (ex. the NumPkts channel or the FirstPacketReceived event).

  Template classes hold information such as the channel/event/packet's id, name,
  argument types, value type, format string, etc. This information is used by
  decoders when parsing data that they receive.


  For each general data type (channel, event, etc) there is a type class.
  Instances of these classes hold information about a specific channel reading or
  event. They contain the actual data parsed by the decoders. As such, they are
  the data type returned by encoders. All of these classes have a time field are
  derived from type SysData, which implements a compare function, allowing any list
  of SysData objects to be sorted by time. Each inherited type should also
  implement the __str__ method so the objects can be easily printed.

  Each instance of a type class also has a reference to the corresponding template
  class for that channel or event type.


  Loaders are used to construct dictionaries of channel and events. These
  dictionaries have template classes as values and ids or names as keys.

  Each dictionary type has their own loader, but subclassing is used to prevent
  code duplication. For example, there are loaders for channel and event python
  file dictionaries, but they both subclass the python loader class which provides
  helper functions for reading python file dictionaries.


  Decoders are responsible for parsing the message data for a specific descriptor
  type.

  Each decoder uses dictionaries produced by loaders to help with its parsing.
  These are given to the decoder's constructor.

  The knowledge for how to parse that descriptor type should stay within the
  decoder. Each decoder type takes in the binary message data, parses it, and
  sends the resulting data object to all consumers registered to it.


  Encoders are responsible for taking data objects from consumers (GUI panels),
  converting them to binary data, and passing them to the TCP client to send to
  the F´ deployment.

  Like the decoders, encoders use dictionaries produced by loaders to help craft
  the binary output.


  Consumers do not have a specific base class, but instead simply implement a data
  callback method that is called by decoders with parsed data objects as the
  argument. In the case of the Gds, the consumers are the GUI panels that display
  data. Consumers can also produce data that is sent to encoders and eventually on
  to the F´ deployment.


  This class is responsible for setting up the pipeline of data between different
  components in the publisher/subscriber interface - that is, it is
  responsible for registering all of the various components that wish to share
  data. This class also supports the creation of multiple Gds GUI windows which
  all share the same subscriptions and therefore receive the same data.


  The `ConfigManager` class is responsible for storing configurations used by GDS
  classes. An instance of this class is passed to some GDS classes such as
  distributors and encoders (to indicate the types of some binary data fields) and
  to some consumers (to indicate colors). The ConfigManager class sets the defaults
  for each config, but a .ini file can also be passed into the constructor to set
  the configs to custom values.


  To setup the structure of the GDS, instances of the above classes are first
  created. Then, they are registered to one another by calling the data producer's
  `register` function with the data consumer as the argument. The data consumer
  is expected to implement a callback function to receive the data (`data_callback`
  for most classes, but check the base class's documentation for details).

  An example of how to instantiate and register classes into the correct structure
  can be found in the `MainFrameFactory` class.


  The Gds requires the packages specified in [setup.py](setup.py).

  These can be installed along the Gds package using the following commands:

  ```
  pip install --upgrade fprime-gds
  ```

  For full installation instructions, including virtual environment creation and installation verification, see [INSTALL.md](https://github.com/nasa/fprime/blob/devel/docs/INSTALL.md).


  You can generate a doxygen documentation page for the GDS source.
  To do this, you will need to install `doxygen`, `doxypypy` and `graphviz`.


  ```
  apt-get install doxygen graphviz
  pip install doxypypy
  ```


  Install doxygen from the website (http://www.stack.nl/~dimitri/doxygen/download.html) or by using the following command if you have Homebrew
  ```
  brew install doxygen
  brew install graphviz
  pip install doxypypy
  ```

  Next, make `docs/py_filter` available in your system path however you see fit.
  Now you can run `doxygen Doxyfile` in the root directory to generate documentation in `docs/doxy/index.html`


   - Currently, the models/common directory has command.py, event.py, and
     channel.py. These files must be present in order for the python dictionaries
     to be properly imported. However, they are empty and not used in the GDS.
     When we switch fully to XML dictionaries, these can go away.

rpm_license:
[cell repeats an earlier one in this file: 10254 characters]


pkgId: 6b540853159fe8e3a0cf3b3f8230cb3f9fa4d9d103e7db6199b20956039b088b
name: python-fpx-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for fpx
url: https://github.com/DataShades/fpx
rpm_license: AGPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fpx-0.7.0-1.src.rpm
location_href: Packages/python-fpx-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  Standalone service for collecting content from multiple source into single
  file. Typical usecase is downloading multiple files as archive using single
  link. Internally FPX fetches content from the specified set of URLs and streams
  zip-compressed stream to the end users.



  1. Install `fpx` package
     ```sh
     pip install fpx
     ```
  1. Initialize DB
     ```sh
     fpx db up
     ```
  1. Start FPX server
     ```sh
     fpx server run
     ```





  Majority of FPX endpoints are available only via *client's secret*. It can be
  generated via CLI command(replace `<CLIENT_NAME>` with an arbitrary combination
  of letters, digits and underscores):

  ```sh
  fpx client add <CLIENT_NAME>
  ```

  And secret will be shown in the output of the command:

  ```sh
  Client created: <CLIENT_NAME> - <SECRET>
  ```

  Pass the secret via `Authorization` header with each request to identify
  yourself as a client.



  Downloading a file via FPX usually consists of two steps:

  * Provide information about downloaded URLs and receive IDs of the *download ticket*
  * Use the ticket's ID to download all URLs packed into a single ZIP archive

  First step can be completed via cURL:

  ```sh
  curl -X POST http://localhost:8080/ticket/generate \
      -H "Authorization: <CLIENT_SECRET>" \
      -d '{"items":["https://google.com", "https://google.com/search"]}'
  ```

  Here we are making a POST request to `/ticket/generate` endpoint of FPX
  service. It's requires client's secret, which is specified by `Authorization`
  header. This endpoint works only with JSON requests, that's why we need
  `Content-type`. Finally, body of the request must contain a JSON with an
  `items` field: the list of all URLs we are going to download.

  Response will be the following:
  ```sh
  {"created":"2023-10-15T00:00:51.054523","type":"zip","id":"ca03e214-910d-419f-ad60-4b6fb8bdd10c"}
  ```

  You need only `id` field from it. Use it to make a download URL:
  `/ticket/<ID>/download`. For the example above we receive this URL:
  `http://localhost:8080/ticket/ca03e214-910d-419f-ad60-4b6fb8bdd10c/download`.

  Open it in web browser or use `wget`/`curl` to download file via CLI:

  ```sh
  curl http://localhost:8080/ticket/ca03e214-910d-419f-ad60-4b6fb8bdd10c/download -o collection.zip
  ```



  FPX works without explicit configuration, but default values are not suitable
  for production environments. Config options can be changes via config file and
  environment variables.



  FPX config file is a python script. It's read by FPX and all global variables
  from it are used as config options. For example, the following file will add
  `A` and `B` options to FPX application:

  ```python
  A = 1
  B = ["hello", "world"]
  ```

  Path to this file must be specified via `FPX_CONFIG` environment variable:

  ```
  export FPX_CONFIG=/etc/fpx/config/fpx.py
  fpx server run
  ```



  In addition to config file, FPX reads all environment variables with `FPX_*`
  name, strips `FPX_` prefix and use result as a config option. I.e:
  * `FPX_DB_URL` envvar turns into `DB_URL` config option
  * `FPX_FPX_TRANSPORT` envvar turns into `FPX_TRANSPORT` config option.

  Pay attention to config options with the name starting with `FPX_`. Because
  `FPX_` prefix is removed from envvars, you have to repeat it twice, like in
  `FPX_FPX_TRANSPORT` above.



  FPX makes use of the following config options

  | Name            | Description                                                                        | Default                 |
  |-----------------|------------------------------------------------------------------------------------|-------------------------|
  | `DEBUG`         | Run application in debug mode. Mainly used for development                         | false                   |
  | `HOST`          | Bind application to the specified addres                                           | 0.0.0.0                 |
  | `PORT`          | Run application on the specified port                                              | 8000                    |
  | `DB_URL`        | DB URL used for SQLAlchemy engine                                                  | `sqlite:////tmp/fpx.db` |
  | `FPX_TRANSPORT` | Underlying library for HTTP requests. `aiohttp` and `htmx` supported at the moment | `aiohttp`               |



  1. Install FPX:
     ```sh
     pip install fpx
     ```

  1. Create config file. It can be created anywhere, as long as it accessible by FPX service:
     ```sh
     echo '
     PORT = 12321
     DB_URL = "sqlite:////home/user/.virtualenvs/fpx/fpx.db"
     ' > /etc/fpx/fpx.py
     ```

  1. Initialize database and create access token for client:
     ```sh
     export FPX_CONFIG=/etc/fpx/fpx.py
     fpx db up
     fpx client add my-first-fpx-client  # use any name, that match `[\w_-]`
     ```

     Make sure, db is accessible and writable by FPX service. This
     manual suggests using `www-data` user when configuring supervisor's
     process, so following command required:
     ```sh
     chown www-data:www-data /home/user/.virtualenvs/fpx/fpx.db
     ```

  1. Test service:
     ```sh
      FPX_CONFIG=/etc/fpx/fpx.py fpx server run
      
      FPX_CONFIG=/etc/fpx/fpx.py python -m fpx
      ```

  1. Configure system.d/supervisor/etc. unit for fpx. Make sure, that
     `fpx server run` command, that spins up the service is executed using
     python>=3.6 (`pyenv shell 3.8.2`). And, if SQLite is used, fpx
     process has write access to db file:
     ```ini
     [program:fpx-worker]

     ; Use the full paths to the virtualenv and your configuration file here.
     command=/home/user/.virtualenv/fpx/bin/python -m fpx

     environment=FPX_CONFIG=/etc/fpx/fpx.py

     ; User the worker runs as.
     user=www-data

     ; Start just a single worker. Increase this number if you have many or
     ; particularly long running background jobs.
     numprocs=1
     process_name=s-02d

     ; Log files.
     stdout_logfile=/var/log/fpx-worker.log
     stderr_logfile=/var/log/fpx-worker.log

     ; Make sure that the worker is started on system start and automatically
     ; restarted if it crashes unexpectedly.
     autostart=true
     autorestart=true

     ; Number of seconds the process has to run before it is considered to have
     ; started successfully.
     startsecs=10

     ; Need to wait for currently executing tasks to finish at shutdown.
     ; Increase this if you have very long running tasks.
     stopwaitsecs = 600
     ```

  1. FPX service must be available via public url. As written in
     [documentation](https://sanic.dev/en/guide/deployment/running.html#running-sanic),
     no additional layers required. But if you decide to use it with Nginx, the
     [following
     link](https://sanic.dev/en/guide/deployment/nginx.html#proxied-sanic-app)
     may be useful. Note, if `FPX_NO_QUEUE` config option is set to `False`, FPX
     is using websockets (and it can affect configuration).

     Example of Nginx section for FPX:
     ```conf
     location /fpx/ {
        proxy_pass http://127.0.0.1:12321/;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header Host $host;
        proxy_http_version 1.1;
        proxy_request_buffering off;
        proxy_buffering off;

        
        proxy_set_header connection "upgrade";
        proxy_set_header upgrade $http_upgrade;

        
        
     }
     ```

     Example of httpd configuration:
     ```cond
     
     
     ProxyPass /fpx/ http://0.0.0.0:8000/
     ProxyPassReverse /fpx/ http://0.0.0.0:8000/

     
     
     
     RewriteEngine on
     RewriteCond %{HTTP:UPGRADE} ^WebSocket$ [NC]
     RewriteCond %{HTTP:CONNECTION} ^Upgrade$ [NC]
     RewriteRule /fpx/(.*) ws://0.0.0.0:8000/$1 [P]
     ```


pkgId: 5ef19096d653723051452e4c2494cbdb38464da3ef3ac5964d0cec5c1fe281f0
name: python-fractal-faim-ipa-help
arch: noarch
version: 0.4.4
epoch: 0
release: 1
summary: Development documents and examples for fractal-faim-ipa
url: https://pypi.org/project/fractal-faim-ipa/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fractal-faim-ipa-0.4.4-1.src.rpm
location_href: Packages/python-fractal-faim-ipa-help-0.4.4-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/pypi/l/fractal-faim-ipa.svg?color=green)](https://github.com/jluethi/fractal-faim-ipa/raw/main/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/fractal-faim-ipa.svg?color=green)](https://pypi.org/project/fractal-faim-ipa)
  [![Python Version](https://img.shields.io/pypi/pyversions/fractal-faim-ipa.svg?color=green)](https://python.org)
  [![CI](https://github.com/jluethi/fractal-faim-ipa/actions/workflows/ci.yml/badge.svg)](https://github.com/jluethi/fractal-faim-ipa/actions/workflows/ci.yml)

  Provides Fractal tasks for the conversion of Molecular Devices ImageXpress microscope to OME-Zarr.

  The conversion based on the [faim-ipa library](https://github.com/fmi-faim/faim-ipa). This repo also contains some of the test data from the faim-ipa library, as well as test data from the ZMB provided by @fstur.


  Install this package as:

  ```
  pip install fractal-faim-ipa
  ```


  You can add these Fractal tasks to a server by using the pypi installation and specifying the task name fractal-faim-ipa


  1. Merge PR into main
  2. Locally checkout main
  3. Tag the release: git tag v0.4.3
  4. Push the tag to Github: git push origin v0.4.3

  The github workflow will then publish this release to PyPI & create a Github release with the corresponding whl file.


pkgId: f15a87ad6916752a329c0029de301f42f174c308dadb29faa6c498292a032553
name: python-fractal-server-help
arch: noarch
version: 2.10.2
epoch: 0
release: 1
summary: Development documents and examples for fractal-server
url: https://github.com/fractal-analytics-platform/fractal-server
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fractal-server-2.10.2-1.src.rpm
location_href: Packages/python-fractal-server-help-2.10.2-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://raw.githubusercontent.com/fractal-analytics-platform/fractal-logos/refs/heads/main/projects/fractal_server.png" alt="Fractal server" width="400">
  </p>

  [![PyPI version](https://img.shields.io/pypi/v/fractal-server?color=gree)](https://pypi.org/project/fractal-server/)
  [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![CI Status](https://github.com/fractal-analytics-platform/fractal-server/actions/workflows/ci.yml/badge.svg)](https://github.com/fractal-analytics-platform/fractal-server/actions/workflows/ci.yml?query=branch%3Amain)
  [![Coverage](https://raw.githubusercontent.com/fractal-analytics-platform/fractal-server/python-coverage-comment-action-data/badge.svg)](https://htmlpreview.github.io/?https://github.com/fractal-analytics-platform/fractal-server/blob/python-coverage-comment-action-data/htmlcov/index.html)
  [![Documentation Status](https://github.com/fractal-analytics-platform/fractal-server/actions/workflows/documentation.yaml/badge.svg)](https://fractal-analytics-platform.github.io/fractal-server)
  [![Benchmarks](https://img.shields.io/badge/Benchmarks-Done-blue)](https://htmlpreview.github.io/?https://github.com/fractal-analytics-platform/fractal-server/blob/benchmark-api/benchmarks/bench.html)

  [Fractal](https://fractal-analytics-platform.github.io/) is a framework developed at the [BioVisionCenter](https://www.biovisioncenter.uzh.ch/en.html) to process bioimaging data at scale in the OME-Zarr format and prepare the images for interactive visualization.

  ![Fractal_overview](https://github.com/user-attachments/assets/666c8797-2594-4b8e-b1d2-b43fca66d1df)

  This is the server component of the fractal analytics platform.
  Find more information about Fractal in general and the other repositories at
  the [Fractal home page](https://fractal-analytics-platform.github.io).




  See https://fractal-analytics-platform.github.io/fractal-server.



  Fractal was conceived in the Liberali Lab at the Friedrich Miescher Institute for Biomedical Research and in the Pelkmans Lab at the University of Zurich by [@jluethi](https://github.com/jluethi) and [@gusqgm](https://github.com/gusqgm). The Fractal project is now developed at the [BioVisionCenter](https://www.biovisioncenter.uzh.ch/en.html) at the University of Zurich and the project lead is with [@jluethi](https://github.com/jluethi). The core development is done under contract by [eXact lab S.r.l.](https://www.exact-lab.it).

  Unless otherwise specified, Fractal components are released under the BSD 3-Clause License, and copyright is with the BioVisionCenter at the University of Zurich.

  The SLURM compatibility layer is based on
  [`clusterfutures`](https://github.com/sampsyo/clusterfutures), by
  [@sampsyo](https://github.com/sampsyo) and collaborators, and it is released
  under the terms of the MIT license.


pkgId: 4d3c0bc563d1667628aad9ead3eee3d4ed9cf5c874d674d9163844c73ff9db45
name: python-framegrab-help
arch: noarch
version: 0.9.0
epoch: 0
release: 1
summary: Development documents and examples for framegrab
url: https://www.groundlight.ai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-framegrab-0.9.0-1.src.rpm
location_href: Packages/python-framegrab-help-0.9.0-1.noarch.rpm
checksum_type: sha256
description:
  FrameGrab is an open-source Python library designed to make it easy to grab frames (images) from cameras or streams. The library supports generic USB cameras (such as webcams), RTSP streams, Basler USB cameras, Basler GigE cameras, Intel RealSense depth cameras, and video file streams (mp4, mov, mjpeg, avi, etc.).

  FrameGrab also provides basic motion detection functionality. FrameGrab requires Python 3.7 or higher.



  - [FrameGrab by Groundlight](#framegrab-by-groundlight)
    - [A user-friendly library for grabbing images from cameras or streams](#a-user-friendly-library-for-grabbing-images-from-cameras-or-streams)
    - [Table of Contents](#table-of-contents)
    - [Installation](#installation)
    - [Optional Dependencies](#optional-dependencies)
    - [Usage](#usage)
      - [Command line interface (CLI)](#command-line-interface-cli)
      - [Frame Grabbing](#frame-grabbing)
      - [Configurations](#configurations)
      - [Autodiscovery](#autodiscovery)
        - [RTSP Discovery](#rtsp-discovery)
      - [Motion Detection](#motion-detection)
    - [Examples](#examples)
      - [Generic USB](#generic-usb)
      - [YouTube Live](#youtube-live)
      - [File Stream](#file-stream)
    - [Contributing](#contributing)
    - [License](#license)



  To install the FrameGrab library, simply run:

  ```
  pip install framegrab
  ```


  Certain camera types have additional dependencies that must be installed separately. If you don't intend to use these camera types, you don't need to install these extra packages.

  - To use a Basler USB or GigE camera, you must separately install the `pypylon` package.
  - To use Intel RealSense cameras, you must install `pyrealsense2`.
  - To use a Raspberry Pi "CSI2" camera (connected with a ribbon cable), you must install the `picamera2` library. See install instructions at the [picamera2 github repository](https://github.com/raspberrypi/picamera2).
  - To use a YouTube Live stream, you must install `streamlink`.

  We provide optional extras to install these dependencies. For example, to install the Basler camera dependencies, run:
  ```
  pip install framegrab[basler]
  ```

  To install YouTube Live stream dependencies, run:
  ```
  pip install framegrab[youtube]
  ```

  To install all optional dependencies, run:
  ```
  pip install framegrab[all]
  ```






  There is a simple CLI for `framegrab` to discover and preview configurations.

  ```
  framegrab
  ```

  lists the sub-commands, including `autodiscover` and `preview`.



  Frame Grabbers are defined by a configuration dict which is usually stored as YAML.  The configuration combines the camera type, the camera ID, and the camera options.  The configuration is passed to the `FrameGrabber.create_grabber` method to create a grabber object.  The grabber object can then be used to grab frames from the camera.


  `config` can contain many details and settings about your camera, but only `input_type` is required. Available `input_type` options are: `generic_usb`, `rtsp`, `realsense`, `basler`, `rpi_csi2`, `hls`, `youtube_live`, and `file_stream`.

  Here's an example of a single USB camera configured with several options:
  ```python
  config = """
  name: Raspberry Pi Ribbon Cable Camera
  input_type: rpi_csi2
  options:
      resolution:
          height: 720
          width: 1280
      zoom:
          digital: 1.5
  """

  grabber = FrameGrabber.create_grabber_yaml(config)
  ```

  To get a frame, simply run:
  ```python
  frame = grabber.grab()
  ```
  You can also change the options after the grabber is created.
  ```python
  new_options = {
      'resolution': {
          'height': 480,
          'width': 640,
      },
      'crop': {
          'relative': {
              'top': .1,
              'bottom': .9,
              'left': .1,
              'right': .9,
          }
      }
  }

  grabber.apply_options(new_options)
  ```

  When you are done with the camera, release the resource by running:
  ```python
  grabber.release()
  ```

  Alternatively, you can use a context manager which will automatically release the camera resources:
  ```python
  with FrameGrabber.create_grabber_yaml(config) as grabber:
      frame = grabber.grab()
  ```

  You might have several cameras that you want to use in the same application. In this case, you can load the configurations from a yaml file and use `FrameGrabber.create_grabbers`. Note that currently only a single Raspberry Pi CSI2 camera is supported, but these cameras can be used in conjunction with other types of cameras.

  If you have multiple cameras of the same type plugged in, it's recommended that you include serial numbers in the configurations; this ensures that each configuration is paired with the correct camera. If you don't provide serial numbers in your configurations, configurations will be paired with cameras in a sequential manner.

  Below is a sample yaml file containing configurations for three different cameras.
  ```yaml
  image_sources:
    - name: On Robot Arm
      input_type: basler
      id:
        serial_number: A24P1V4T
      options:
        crop:
          relative:
            top: 0.3
            right: 0.8
    - name: Chip Bin
      input_type: rtsp
      id:
        rtsp_url: rtsp://admin:password@192.168.1.20/cam/realmonitor?channel=1&subtype=0
      options:
        crop:
          pixels:
            top: 350
            bottom: 1100
            left: 1100
            right: 2000
    - name: Over CNC Machine
      input_type: generic_usb
      id:
        serial_number: B77D3A8F
  ```
  You can load the configurations from the yaml file and use the cameras in the following manner.
  ```python
  from framegrab import FrameGrabber

  config_path = 'camera_config.yaml'
  grabbers = FrameGrabber.from_yaml(config_path)

  for grabber in grabbers.values():
      print(grabber.config)
      frame = grabber.grab()
      display_image(frame) # substitute this line for your preferred method of displaying images, such as cv2.imshow
      grabber.release()
  ```

  The table below shows all available configurations and the cameras to which they apply.
  | Configuration Name         | Example         | Generic USB     | RTSP      | Basler    | Realsense | Raspberry Pi CSI2 | HLS | YouTube Live | File Stream |
  |----------------------------|-----------------|------------|-----------|-----------|-----------|-----------|-----------|-----------|-------------|
  | name                       | On Robot Arm    | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | input_type                 | generic_usb    | required   | required  | required  | required  | required  | required | required | required |
  | id.serial_number           | 23458234       | optional   | -         | optional  | optional  | -  | - | - | - |
  | id.rtsp_url                | rtsp://…        | -          | required  | -         | -         | -         | - | - | - |
  | id.hls_url                 | https://.../*.m3u8     | -          | -         | -         | -         | -         | required | - | - |
  | id.youtube_url             | https://www.youtube.com/watch?v=...     | -          | -         | -         | -         | -         | - | required | - |
  | id.filename               | http://.../*.mp4 | -          | -         | -         | -         | -         | - | - | required |
  | options.resolution.height  | 480            | optional   | -         | -         | optional  | -  | - | - | - |
  | options.resolution.width   | 640            | optional   | -         | -         | optional  | -  | - | - | - |
  | options.zoom.digital       | 1.3            | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | options.crop.pixels.top    | 100            | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | options.crop.pixels.bottom | 400            | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | options.crop.pixels.left   | 100            | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | options.crop.pixels.right  | 400            | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | options.crop.relative.top  | 0.1            | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | options.crop.relative.bottom | 0.9          | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | options.crop.relative.left | 0.1            | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | options.crop.relative.right | 0.9            | optional   | optional  | optional  | optional  | optional  | optional | optional | optional |
  | options.depth.side_by_side | 1              | -          | -         | -         | optional  | -  | - | - | - |
  | options.num_90_deg_rotations | 2              | optional          | optional         | optional         | optional  | optional  | optional | optional | optional |
  | options.keep_connection_open | True              | -          | optional         | -         | -  | - | optional | optional | - |
  | options.max_fps | 30              | -          | optional         | -         | -  | - | - | - | optional |


  In addition to the configurations in the table above, you can set any Basler camera property by including `options.basler.<BASLER PROPERTY NAME>`. For example, it's common to set `options.basler.PixelFormat` to `RGB8`.


  Autodiscovery automatically connects to cameras that are plugged into your machine or discoverable on the network, including `generic_usb`, `realsense`, `basler`, and ONVIF supported `rtsp` cameras. Note that `rpi_csi2` cameras are not yet supported by autodiscover. Default configurations will be loaded for each camera. Note that discovery of RTSP cameras will be disabled by default but can be enabled by setting `rtsp_discover_mode`. Refer to [RTSP Discovery](#rtsp-discovery) section for different options.

  Autodiscovery is great for simple applications where you don't need to set any special options on your cameras. It's also a convenient method for finding the serial numbers of your cameras (if the serial number isn't printed on the camera).
  ```python
  grabbers = FrameGrabber.autodiscover()


  for grabber in grabbers.values():
      print(grabber.config)

      grabber.release()
  ```


  RTSP cameras with support for ONVIF can be discovered on your local network in the following way:

  ```python
  from framegrab import RTSPDiscovery, ONVIFDeviceInfo

  devices = RTSPDiscovery.discover_onvif_devices()
  ```

  The `discover_onvif_devices()` will provide a list of devices that it finds in the `ONVIFDeviceInfo` format. An optional mode `auto_discover_mode` can be used to try different default credentials to fetch RTSP URLs:

  - off: No discovery.
  - ip_only: Only discover the IP address of the camera.
  - light: Only try first two usernames and passwords ("admin:admin" and no username/password).
  - complete_fast: Try the entire DEFAULT_CREDENTIALS without delays in between.
  - complete_slow: Try the entire DEFAULT_CREDENTIALS with a delay of 1 seconds in between.


  After getting the list and enter the username and password of the camera. Use `generate_rtsp_urls()` to generate RTSP URLs for each devices.

  ```python
  for device in devices:
      RTSPDiscovery.generate_rtsp_urls(device=device)
  ```

  This will generate all the available RTSP URLs and can be used when creating `FrameGrabber.create_grabbers` to grab frames.

  ```python
  config = f"""
  name: Front Door Camera
  input_type: rtsp
  id:
    rtsp_url: {device.rtsp_urls[0]}
  """

  grabber = FrameGrabber.create_grabber_yaml(config)
  ```



  To use the built-in motion detection functionality, first create a `MotionDetector` object, specifying the percentage threshold for motion detection:

  ```python
  from framegrab import MotionDetector

  motion_threshold = 1.0
  m = MotionDetector(pct_threshold=motion_threshold)
  ```

  The motion threshold is defined as the detection threshold for motion detection, in terms of the percentage of changed pixels. The default value is 1.0 (which means 1%).

  Then, use the `motion_detected()` method with a captured frame to check if motion has been detected:

  ```python
  if m.motion_detected(frame):
      print("Motion detected!")
  ```




  Here's an example of using the FrameGrab library to continuously capture frames and detect motion from a video stream:

  ```python
  from framegrab import FrameGrabber, MotionDetector

  motion_threshold = 1.0
  m = MotionDetector(pct_threshold=motion_threshold)

  config = {
      'input_type': 'generic_usb',
  }

  with FrameGrabber.create_grabber(config) as grabber:
      while True:
          frame = grabber.grab()
          if frame is None:
              print("No frame captured!")
              continue

          if m.motion_detected(frame):
              print("Motion detected!")
  ```


  Here's an example of using FrameGrab to capture frames from a YouTube Live stream:

  ```python
  from framegrab import FrameGrabber
  import cv2

  config = {
      'input_type': 'youtube_live',
      'id': {
          'youtube_url': 'https://www.youtube.com/watch?v=your_video_id'
      }
  }

  with FrameGrabber.create_grabber(config) as grabber:
      frame = grabber.grab()
      if frame is None:
          raise Exception("No frame captured")

      
      
      
      cv2.imwrite('youtube_frame.jpg', frame)
  ```


  Here's an example of using FrameGrab to capture frames from a video file:

  ```python
  from framegrab import FrameGrabber
  import cv2

  config = {
      'input_type': 'file_stream',
      'id': {
          'filename': 'path/to/your/video.mjpeg'  # or .mp4, .avi, .mov, etc.
      },
      'options': {
          'max_fps': 2,  # if a lower FPS than the original video's FPS is specified, Framegrab will skip extra frames as needed.
      }
  }

  with FrameGrabber.create_grabber(config) as grabber:
    frame = grabber.grab()
    if frame is None:
        raise Exception("No frame captured")

    
    
    
    cv2.imwrite('file_stream_frame.jpg', frame)
  ```



  We welcome contributions to FrameGrab! If you would like to contribute, please follow these steps:

  1. Fork the repository
  2. Create a new branch for your changes
  3. Commit your changes to the branch
  4. Open a pull request



  FrameGrab is released under the MIT License. For more information, please refer to the [LICENSE.txt](https://github.com/groundlight/framegrab/blob/main/LICENSE.txt) file.


pkgId: 455a2d10af33df618eae32b1cc6e830c3527492f2427a57e620fcabfaed429cb
name: python-framex-help
arch: noarch
version: 0.10.0
epoch: 0
release: 1
summary: Development documents and examples for framex
url: https://pypi.org/project/framex/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-framex-0.10.0-1.src.rpm
location_href: Packages/python-framex-help-0.10.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Banner](https://github.com/datavil/framex/blob/master/.github/framex_banner_narrower.png?raw=true)
  A [DataVil](https://github.com/datavil) project.



  [![GitHub](https://img.shields.io/badge/GitHub-100000?style=flat&logo=github&logoColor=white)](https://github.com/DataVil/framex) [![PyPI](https://img.shields.io/pypi/v/framex?color=blue)](https://pypi.org/project/framex/)

  **FrameX** is a light-weight, dataset fetching library for fast **prototyping**, **tutorial creation**, and **experimenting**.

  Built on top of [Polars](https://pola.rs/).



  To get started, install the library with:

  ``` shell
  pip install framex
  ```





  ``` python
  import framex as fx
  ```



  ``` python
  iris = fx.load("iris")
  ```

  which returns a [**polars DataFrame**](https://docs.pola.rs/api/python/stable/reference/dataframe/index.html)\
  Therefore, you can use all the **polars** functions and methods on the returned **DataFrame**.

  ``` python
  iris.head()
  ```

  ``` text
  shape: (5, 5)
  ┌──────────────┬─────────────┬──────────────┬─────────────┬─────────┐
  │ sepal_length ┆ sepal_width ┆ petal_length ┆ petal_width ┆ species │
  │ ---          ┆ ---         ┆ ---          ┆ ---         ┆ ---     │
  │ f32          ┆ f32         ┆ f32          ┆ f32         ┆ str     │
  ╞══════════════╪═════════════╪══════════════╪═════════════╪═════════╡
  │ 5.1          ┆ 3.5         ┆ 1.4          ┆ 0.2         ┆ setosa  │
  │ 4.9          ┆ 3.0         ┆ 1.4          ┆ 0.2         ┆ setosa  │
  │ 4.7          ┆ 3.2         ┆ 1.3          ┆ 0.2         ┆ setosa  │
  │ 4.6          ┆ 3.1         ┆ 1.5          ┆ 0.2         ┆ setosa  │
  │ 5.0          ┆ 3.6         ┆ 1.4          ┆ 0.2         ┆ setosa  │
  └──────────────┴─────────────┴──────────────┴─────────────┴─────────┘
  ```

  ``` python
  iris = fx.load("iris", lazy=True)
  ```

  which returns a [**polars LazyFrame**](https://docs.pola.rs/api/python/stable/reference/lazyframe/index.html)

  Both these operations create local copies of the datasets by default `cache=True`.



  To see the list of available datasets, run:

  ``` python
  fx.available()
  ```

  ``` python
  {'remote': ['iris', 'mpg', 'netflix', 'starbucks', 'titanic'], 'local': ['titanic']}
  ```

  which returns a dictionary of both **locally** and **remotely** available datasets.

  To see only **local** or **remote** datasets, run:

  ``` python
  fx.available("local")
  fx.available("remote")
  ```

  ``` python
  {'local': ['titanic']}
  {'remote': ['iris', 'mpg', 'netflix', 'starbucks', 'titanic']}
  ```



  To get information on a dataset, run:

  ``` python
  fx.about("mpg") # basically the same as `fx.about("mpg", mode="print")`
  ```

  which will print the information on the dataset as the following:

  ``` text
  NAME    : mpg
  SOURCE  : https://www.kaggle.com/datasets/uciml/autompg-dataset
  LICENSE : CC0: Public Domain
  ORIGIN  : Kaggle
  OG NAME : autompg-dataset
  ```

  Or you can get the information as a single row polars.DataFrame by running:

  ``` python
  row = fx.about("mpg", mode="row")
  print(row)
  ```

  which will print the information on the dataset **ASCII art** as the following:

  ``` text
  shape: (1, 4)
  ┌──────┬─────────────────────────────────┬────────────────────┬────────┐
  │ name ┆ source                          ┆ license            ┆ origin │
  │ ---  ┆ ---                             ┆ ---                ┆ ---    │
  │ str  ┆ str                             ┆ str                ┆ str    │
  ╞══════╪═════════════════════════════════╪════════════════════╪════════╡
  │ mpg  ┆ https://www.kaggle.com/dataset… ┆ CC0: Public Domain ┆ Kaggle │
  └──────┴─────────────────────────────────┴────────────────────┴────────┘
  ```

  or you can simply treat `row` as a polars DataFrame in your code.



  In case you need the file links.

  ``` python
  url_pokemon = fx.get_url("pokemon")
  ```

  by default, the format is " feather".

  Optionally, you can specify the format of the dataset.

  ``` python
  url_pokemon_csv = fx.get_url("pokemon", format="csv")
  ```





  Get a single dataset:

  ``` shell
  fx get iris
  ```

  or get multiple datasets:

  ``` shell
  fx get iris mpg titanic
  ```

  which will download dataset(s) to the current directory.

  to get the datasets into cache directory:

  ``` shell
  fx get iris mpg titanic --cache
  ```

  or to a specific directory:

  ``` shell
  fx get iris mpg titanic --dir data
  ```



  To get the name of the available datasets on the **remote server**.

  ``` shell
  fx list
  ```

  this will list all available datasets on the remote server.



  To get information on a dataset or datasets, run:

  ``` shell
  fx about mpg iris
  ```



  To show a preview of a single dataset

  ``` shell
  fx show iris
  ```



  To describe (or summarize) a dataset

  ``` shell
  fx describe iris
  ```

  For more parameters

  ``` shell
  fx get --help
  ```


pkgId: 5b9a7a624ef99734dc3875fdc2b41901f7526c64007f80edc15262512cb674ee
name: python-free-bandcamp-downloader-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for free-bandcamp-downloader
url: https://pypi.org/project/free-bandcamp-downloader/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-free-bandcamp-downloader-0.4.0-1.src.rpm
location_href: Packages/python-free-bandcamp-downloader-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Download free and $0 minimum name-your-price albums and tracks from Bandcamp (including ones that are sent to email),
  and tag them with data from the Bandcamp page. Also able to download items in your collection, if login cookies are
  supplied using the `--cookies` or `--identity` argument.



  Install with pip
  ```
  pip install free-bandcamp-downloader
  ```



  Only one cookie is needed to login, which has the name "identity". You can pass this cookie to `bcdl-free` using the
  `--cookies` argument which you must supply a path to a Netscape cookies.txt formatted file, or using the `--identity`
  argument which you must supply the value of your "identity" cookie.



  ```
  Usage:
      bcdl-free (-a <URL> | -l <URL>)[--force][--no-unzip][-d | --dir <dir>][-e | --email <email>]
          [-z | --zipcode <zipcode>][-c | --country <country>][-f | --format <format>]
          [--cookies <file>][--identity <value>][--debug]
      bcdl-free setdefault [-d | --dir <dir>][-e | --email <email>][-z | --zipcode <zipcode>]
          [-c | --country <country>][-f | --format <format>]
      bcdl-free defaults
      bcdl-free clear
      bcdl-free (-h | --help)
      bcdl-free --version
  Options:
      -h --help                   Show this screen
      --version                   Show version
      -a <URL>                    Download the album at URL
      -l <URL>                    Download all free albums of the label at URL
      --force                     Download even if album has been downloaded before
      --no-unzip                  Don't unzip downloaded albums
      setdefault                  Set default options
      defaults                    List the default options
      clear                       Clear download history
      -d --dir <dir>              Set download directory
      -c --country <country>      Set country
      -z --zipcode <zipcode>      Set zipcode
      -e --email <email>          Set email (set to 'auto' to automatically download from a disposable email)
      -f --format <format>        Set format
      --cookies <file>            Path to cookies.txt file so albums in your collection can be downloaded
      --identity <value>          Value of identity cookie so albums in your collection can be downloaded
      --debug                     Set loglevel to debug
  Formats:
      - FLAC
      - V0MP3
      - 320MP3
      - AAC
      - Ogg
      - ALAC
      - WAV
      - AIFF
  ```


pkgId: cbb2dac437bef3d4b43918061e640f8ffd099fd76448ca331fff7cd3cc071336
name: python-freeact-skills-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for freeact-skills
url: https://github.com/gradion-ai/freeact-skills
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-freeact-skills-0.0.1-1.src.rpm
location_href: Packages/python-freeact-skills-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Library of predefined [freeact](https://github.com/gradion-ai/freeact) agent skills.



  ```bash
  conda env create -f environment.yml
  conda activate freeact-skills
  poetry install --all-extras
  ```


pkgId: 39d78d7d323a8b99d08d1a7319e48f9f9056522493964e699c1b516083d85065
name: python-freebox-api-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for freebox-api
url: https://github.com/hacf-fr/freebox-api
rpm_license: GNU GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-freebox-api-1.2.0-1.src.rpm
location_href: Packages/python-freebox-api-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  |PyPI| |GitHub Release| |Python Version| |License|
  |Read the Docs| |Tests| |Codecov| |GitHub Activity|
  |pre-commit| |Black|


pkgId: d73df338a547e3b6e5bc5b51ba769b9a113a7b172078d0c245bfdddad1464ac0
name: python-freesif-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for freesif
url: https://github.com/agrav/freesif
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-freesif-0.2.0-1.src.rpm
location_href: Packages/python-freesif-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Packaging, unit testing and deployment to [PyPi](https://pypi.org) is automated using GitHub Actions.

  We apply the "major.minor.micro" versioning scheme defined in [PEP 440](https://www.python.org/dev/peps/pep-0440/).
  Cut a new version by applying a Git tag like `1.0.1` at the desired commit and then
  [setuptools_scm](https://github.com/pypa/setuptools_scm/#setup-py-usage) takes care of the rest. For the versions
  available, see the [tags on this repository](https://github.com/agrav/freesif/tags).

  * **Audun Gravdal Johansen** - [agrav](https://github.com/agrav)

  * **Audun Gravdal Johansen** - [agrav](https://github.com/agrav)
  * **Per Voie** - [tovop](https://github.com/tovop)

  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


pkgId: a4efd35ae0270adb630a4f286a035f1056332f9bfcdc152ef14d309e03cda1ac
name: python-friTap-help
arch: noarch
version: 1.2.6.4
epoch: 0
release: 1
summary: Development documents and examples for friTap
url: https://github.com/fkie-cad/friTap
rpm_license: GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-friTap-1.2.6.4-1.src.rpm
location_href: Packages/python-friTap-help-1.2.6.4-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://raw.githubusercontent.com/fkie-cad/friTap/main/assets/logo.png" alt="friTap logo" width="50%" height="50%"/>
  </p>


  ![version](https://img.shields.io/badge/version-1.2.6.4-blue) [![PyPI version](https://d25lcipzij17d.cloudfront.net/badge.svg?id=py&r=r&ts=1683906897&type=6e&v=1.2.6.4&x2=0)](https://badge.fury.io/py/friTap)

  friTap is a powerful tool designed to assist researchers in analyzing network traffic encapsulated in SSL/TLS. With its ability to automate key extraction, friTap is especially valuable when dealing with malware analysis or investigating privacy issues in applications. By simplifying the process of decrypting and inspecting encrypted traffic, friTap empowers researchers to uncover critical insights with ease.

  Key features include seamless support for automated SSL/TLS key extraction, making it an ideal choice for scenarios requiring rapid and accurate traffic analysis. Whether you’re dissecting malicious network behavior or assessing data privacy compliance, friTap streamlines your workflow.

  For more details, explore the [OSDFCon webinar slides](assets/friTapOSDFConwebinar.pdf) or check out our [blog post](https://lolcads.github.io/posts/2022/08/fritap/).


  This project was inspired by [SSL_Logger](https://github.com/google/ssl_logger ) and currently supports all major operating systems (Linux, Windows, Android). More platforms and libraries will be added in future releases.



  The main features of friTap are:

  - TLS key extraction in real time (`-k key.log`)
  - Decryption of TLS payload as PCAP in real time (`-p plaintext.pcap`)
  - Integration with Python. [Learn more](https://github.com/fkie-cad/friTap/blob/main/INTEGRATION.md)
  - Support for custom Frida scripts. [Details](https://github.com/fkie-cad/friTap/blob/main/USAGE.md#Using-friTap-with-a-custom-Frida-scripts)
  - Support of most common SSL libraries (OpenSSL, BoringSSL, NSS, GnuTLS, etc.)



  Installation is simply a matter of `pip3 install fritap`. This will give you the `fritap` command. You can update an existing `fritap` installation with `pip3 install --upgrade fritap`.



  On Linux/Windows/MacOS we can easily attach to a process by entering its name or its PID:

  ```bash
  $ sudo fritap --pcap mycapture.pcap thunderbird
  ```

  For mobile applications we just have to add the `-m` parameter to indicate that we are now attaching (or spawning) an Android or iOS app:

  ```bash
  $ fritap -m -k keys.log com.example.app
  ```

  Further ensure that the frida-server is running on the Android/iOS device.


  Remember when working with the pip installation you have to invoke the `fritap` command with sudo a little bit different. Either as module:
  ```bash
  $ sudo -E python3 -m friTap.friTap --pcap mycapture.pcap thunderbird
  ```
  or directly invoking the script:
  ```bash
  $ which friTap
  /home/daniel/.local/bin/friTap

  $ sudo -E /home/daniel/.local/bin/friTap
  ```

  friTap can also be used as a Python library within your project:
  ```python
  from friTap import SSL_Logger
  ```
  For more details on integrating friTap into your Python project, check out the [INTEGRATION.md](./INTEGRATION.md) guide.

  friTap allows you to enhance its functionality by providing a custom Frida script during your session. This custom script will be invoked just before friTap applies its own hooks. To do so, use the `-c` parameter ([more](./USAGE.md#Using-friTap-with-a-custom-Frida-scripts)).
  More examples on using friTap can be found in the [USAGE.md](./USAGE.md). A detailed introduction using friTap on Android is under [EXAMPLE.md](./EXAMPLE.md) as well.



  In certain scenarios, the library we want to hook offers no symbols or is statically linked with other libraries, making it challenging to directly hook functions. For example Cronet (`libcronet.so`) and Flutter (`libflutter.so`) are often statically linked with **BoringSSL**.

  Despite the absence of symbols, we can still use friTap for parsing and hooking.



  To solve this, we can use friTap with byte patterns to hook the desired functions. You can provide friTap with a JSON file that contains byte patterns for hooking specific functions, based on architecture and platform using the `--patterns <byte-pattern-file.json>` option.
  In order to apply the apprioate hooks for the various byte patterns we distinguish between different hooking categories.
  These categories include:

    -  Dump-Keys
    -  Install-Key-Log-Callback
    -  KeyLogCallback-Function
    -  SSL_Read
    -  SSL_Write

  Each category has a primary and fallback byte pattern, allowing flexibility when the primary pattern fails.
  For libraries like BoringSSL, where TLS functionality is often statically linked into other binaries, we developed a tool called [BoringSecretHunter](https://github.com/monkeywave/BoringSecretHunter). This tool automatically identifies the necessary byte patterns to hook BoringSSL by byte-pattern matching. Specifically, BoringSecretHunter focuses on identifying the byte patterns for functions in the Dump-Keys category, allowing you to extract encryption keys during TLS sessions with minimal effort. More about the different hooking categories can be found in [usage of byte-patterns in friTap](./USAGE.md#hooking-by-byte-patterns).



  Alternatively, you can use the `--offsets <offset-file.json>` option to hook functions using known offsets. friTap allows you to specify user-defined offsets (relative to the base address of the targeting SSL/socket library) or absolute virtual addresses for function resolution. This is done through a JSON file, which is passed using the `--offsets` parameter.

  If the `--offsets` parameter is used, friTap will only overwrite the function addresses specified in the JSON file. For functions that are not specified, friTap will attempt to detect the addresses automatically (using symbols).




  The absence of traffic or incomplete traffic capture in the resulting pcap file (-p <your.pcap>) may stem from various causes. Before submitting a new issue, consider attempting the following solutions:



  There might be instances where friTap fails to retrieve socket information. In such scenarios, running friTap with default socket information (`--enable_default_fd`) could resolve the issue. This approach utilizes default socket information (127.0.0.1:1234 to 127.0.0.1:2345) for all traffic when the file descriptor (FD) cannot be used to obtain socket details:

  ```bash
  fritap -m --enable_default_fd -p plaintext.pcap com.example.app
  ```



  Traffic originating from a subprocess could be another contributing factor. To capture this traffic, friTap can leverage Frida's spawn gating feature, which intercepts newly spawned processes using the `--enable_spawn_gating` parameter:

  ```bash
  fritap -m -p log.pcap --enable_spawn_gating com.example.app
  ```



  In cases where the target library solely supports key extraction (cf. the table below), you can utilize the `-k <key.log>` parameter alongside full packet capture:

  ```bash
  fritap -m -p log.pcap --full_capture -k keys.log com.example.app
  ```



  If these approaches do not address your issue, please create a detailed issue report to aid in troubleshooting. To facilitate a more effective diagnosis, include the following information in your report:

  - The operating system and its version
  - The specific application encountering the issue or a comparable application that exhibits similar problems
  - The output from executing friTap with the specified parameters, augmented with friTap's debug output:
  ```bash
  fritap -do -v com.example.app
  ```




  ```markdown
  | Library                   | Linux         | Windows       | MacOSX   | Android  | iOS          |
  |---------------------------|---------------|---------------|----------|----------|--------------|
  | OpenSSL                   |     Full      | R/W-Hook only |  TBI     |   Full   | TBI          |
  | BoringSSL                 |     Full      | R/W-Hook only |  KeyEo   |   Full   | KeyEo        |
  | NSS                       |     Full      | R/W-Hook only |  TBI     |   TBA    | TBI          |
  | GnuTLS                    | R/W-Hook only | R/W-Hook only |  TBI     |   Full   | TBI          |
  | WolfSSL                   | R/W-Hook only | R/W-Hook only |  TBI     |   Full   | TBI          |
  | MbedTLS                   | R/W-Hook only | R/W-Hook only |  TBI     |   Full   | TBI          |
  | Bouncycastle/Spongycastle |     TBA       |    TBA        |  TBA     |   Full   | TBA          |
  | Conscrypt                 |     TBA       |    TBA        |  TBA     |   Full   | TBA          |
  | S2n-tls                   |     Full      |    LibNO      |  TBA     |   Full   | LibNO        |
  ```
  **R/W-Hook only** = Logging data sent and received by process<br>
  **KeyEo** = Only the keying material can be extracted<br>
  **Full** = Logging data send and received by process + Logging keys used for secure connection<br>
  **TBA** = To be answered<br>
  **TBI** = To be implemented<br>
  **LibNO** = This library is not supported for this plattform<br>

  **We verified the Windows implementations only for Windows 10**



  - [frida](https://frida.re)
  - `>= python3.7`
  - click (`python3 -m pip install click`)
  - hexdump (`python3 -m pip install hexdump`)
  - scapy (`python3 -m pip install scapy`)
  - watchdog (`python3 -m pip install watchdog`)
  - importlib.resources  (`python3 -m pip install importlib-resources`)
  - AndroidFridaManager (`python3 -m pip install AndroidFridaManager`)
  - for hooking on Android ensure that the `adb`-command is in your PATH



  - [ ] add the capability to alter the decrypted payload
    - integration with https://github.com/mitmproxy/mitmproxy
    - integration with http://portswigger.net/burp/
  - [ ] add wine support
  - [x] <strike>add Flutter support</strike>
  - [ ] add further libraries (have a look at this [Wikipedia entry](https://en.wikipedia.org/wiki/Comparison_of_TLS_implementations)):
    - Botan (BSD license, Jack Lloyd)
    - LibreSSL (OpenBSD)
    - Cryptlib (Peter Gutmann)
    - JSSE (Java Secure Socket Extension, Oracle)
    - [MatrixSSL](https://github.com/matrixssl/matrixssl)
    - ...
  - [x] <strike>Working with static linked libraries</strike>
  - [x] <strike>Add feature to prototype TLS-Read/Write/SSLKEY functions</strike>
  - [ ] improve iOS/MacOS support (currently under development)



  Contributions are always welcome. Just fork it and open a pull request!
  More details can be found in the [CONTRIBUTION.md](./CONTRIBUTION.md).
  ___



  See the wiki for [release notes](https://github.com/fkie-cad/friTap/wiki#news).



  If you have any suggestions, or bug reports, please create an issue in the Issue Tracker.

  In case you have any questions or other problems, feel free to send an email to:

  [daniel.baier@fkie.fraunhofer.de](mailto:daniel.baier@fkie.fraunhofer.de).


pkgId: 06bd197daa3d42ff9682725222cd123dfb65f7f35f7214f3a0bf253f5ad38d83
name: python-frid-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for frid
url: https://github.com/Ask-Here-First/ahf-generic
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-frid-0.6.1-1.src.rpm
location_href: Packages/python-frid-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  This Python package is a tool for data manipulation.
  Supported data types include:
  - All JSON types: string, integer, floating point, boolean, null,
    array (as Python lists), and object (as Python dictionaries).
  - Additional data types: binary types (bytes/bytearray/memoryview) and
    date types (date/time/datetime).
  - Base classes are provided for user-extensible data structures,
    allowing users to convert between any customized data structures
    and string representations.
  Current key features include:
  - A data serialization/deserialization tool:
      + Data can be dumped into and loaded from a string representation that is
        more concise than the JSON format.
      + The library is capable of encoding data in fully JSON- or JSON5-compatible
        formats, including escape sequences in strings to support additional data
        types.
  - A number of utilities functions and classes, including some asyncio utilities.
  - A key/value store supporting memory, file system, redis, and sqlalchemy
    as backends.
  - Web application support tools, such as:
      + Converting data from HTTP request bodies based on content type.
      + Converting data types to HTTP requests and setting the correct headers.
      + Sending streaming responses if the data of the body comes from an
        asynchronous iterator.
      + A mimimal web server routing framework, supporting both WSGi and ASGi.
      + Websocket support for ASGi.
  Dependencies:
  The package do not have required dependencies, but it needs a few optional
  dependencies to run some features:
  - `redis`: for Redis support; also a system command `redis-server` to run
    unit tests.
  - `sqlalchemy`: for SQL support, with some additional packages depending on
    backend; to run async key/value store with Sqlite, one need `aiosqlite`
    and `greenlet` to run the unit tests. For Postgres, the following are
    needed:
      + `psycopg[binary]` for sync Postgres support,
      + `asyncpg` for async Postgres support.
  - For web servers:
      + `gunicorn` to run WSGi unit tests.
      + `uvicorn`  to run ASGi unit tests.
  - For websocket support (ASGi only):
      + `websockets` with `uvicorn` (or install `uvicorn[standard]`);
        it also allows us to run websockets' threading-based sync client
        for unit tests.
      + `websocket-client` to run websocket-client-based unit tests.
  Other possibilities that haven't been tested:
  - For ASGi: `daphne` and `hypercorn`;
  - For ASGi with `uvicorn`: `wsproto` is an alternative to `websockets`.


pkgId: eb256b302ee65f571b68e4c25b4275ee82b170301d0a99690972fad1435b997e
name: python-fronius_solarweb-help
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: Development documents and examples for fronius_solarweb
url: https://github.com/drc38/python-fronius-web
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fronius_solarweb-0.3.3-1.src.rpm
location_href: Packages/python-fronius_solarweb-help-0.3.3-1.noarch.rpm
checksum_type: sha256
description:
  Python client for the Fronius [Solar.web API](https://www.fronius.com/~/downloads/Solar%20Energy/User%20Information/SE_UI_API_InterfaceDocumentation_EN.pdf).



  - Talks to your Fronius Solar.web PV system via Cloud API
  - Automatic retries with exponential backoff
  - Optionally pass in a `httpx` client



  Although intended as a library [`fronius_sw_example.py`](https://github.com/drc38/python-fronius-web/blob/main/examples/fronius_sw_example.py) is provided for testing purposes.

  Authentication and PV system id for the example is provided via environment variables, e.g. on nix systems:

  ```
  export ACCESS_KEY_ID=FKIAFEF58CFEFA94486F9C804CF6077A01AB
  export ACCESS_KEY_VALUE=47c076bc-23e5-4949-37a6-4bcfcf8d21d6
  export PV_SYSTEM_ID=20bb600e-019b-4e03-9df3-a0a900cda689
  ```


pkgId: d67e69510d2294f2a60c5a2cd5e70527fc90eb51b78fd4a8c94d014201186071
name: python-fs-search-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for fs-search
url: https://github.com/voyager-2021/fs-search
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fs-search-0.1.2-1.src.rpm
location_href: Packages/python-fs-search-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  `fs-search` is a command-line tool that allows you to search for files and directories within a specified base path. You can customize your search by including or excluding specific file extensions and directories, and the results can be displayed in a user-friendly format with options to save them to a file.



  - Search for files and directories starting from a specified base path.
  - Exclude files based on extensions (`-e`).
  - Exclude directories from the search (`-E`).
  - Search only for files (`-f`) or only for directories (`-d`).
  - Save the results to a file (`-o`).
  - Display relative paths instead of full paths (`-r`).
  - Supports cross-platform usage with `pathlib`.
  - Colorful output using `colorama`.
  - Easily extendable for future features.



  You can install `fs-search` via pip:

  ```bash
  pip install fs-search
  ```





  Search the current directory for files and directories:

  ```bash
  fs-search
  ```



  Exclude specific file extensions from the search:

  ```bash
  fs-search -e .log -e .tmp
  ```



  Exclude specific directories from the search:

  ```bash
  fs-search -E node_modules -E .git
  ```



  Search only for files (excluding directories):

  ```bash
  fs-search -f
  ```



  Search only for directories (excluding files):

  ```bash
  fs-search -d
  ```



  Save the search results to a file:

  ```bash
  fs-search -o results.txt
  ```



  Display relative paths instead of full paths:

  ```bash
  fs-search -r
  ```



  You can combine multiple options:

  ```bash
  fs-search -b /path/to/search -e .log -E node_modules -f -o results.txt
  ```



  To contribute to `fs-search`, you can clone the repository and install the necessary dependencies:

  ```bash
  git clone https://github.com/voyager-2021/fs-search.git
  cd fs-search
  pip install -e .[dev]
  ```



  Run mypy before commiting. To run mypy (using `mypy`), simply run:

  ```bash
  mypy search_fs --strict
  ```


  Optimize lol.



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.



  - [GitHub Repository](https://github.com/voyager-2021/fs-search)
  - [Bug Tracker](https://github.com/voyager-2021/fs-search/issues)


pkgId: 2ab86aff6dd3b1e1575d0d29bf59522de20b89dddf2bc967426f8d8ea1cc4384
name: python-fsl-pipe-gui-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for fsl-pipe-gui
url: https://git.fmrib.ox.ac.uk/ndcn0236/fsl-pipe-gui
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fsl-pipe-gui-0.2.0-1.src.rpm
location_href: Packages/python-fsl-pipe-gui-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/fsl-pipe-gui)](https://pypi.org/project/fsl-pipe-gui/)
  [![Documentation](https://img.shields.io/badge/Documentation-fsl--pipe-blue)](https://open.win.ox.ac.uk/pages/ndcn0236/fsl-pipe)
  [![Pipeline status](https://git.fmrib.ox.ac.uk/ndcn0236/fsl-pipe-gui/badges/main/pipeline.svg)](https://git.fmrib.ox.ac.uk/ndcn0236/fsl-pipe-gui/-/pipelines/latest)

  Terminal-based GUI for fsl-pipe.
  It allows interactively choosing which subset of potential output files you want an fsl-pipe pipeline to produce.


  ```shell
  pip install fsl-pipe-gui
  ```

  Any bug reports and feature requests are very welcome (see [issue tracker](https://git.fmrib.ox.ac.uk/ndcn0236/fsl-pipe-gui/-/issues)).


  For any pipelines using the standard command line interface, the GUI will be available using the `-g/--gui` flag.
  Some pipelines might have customised this flag. Please check their documentation.

  When starting the GUI from your own custom python code, you will need:
  - a `file_tree` describing the paths of the input and output files (see [file-tree](https://open.win.ox.ac.uk/pages/ndcn0236/file-tree)).
  - a `pipeline` containing the recipes to produce the output from the input files (see [fsl-pipe](https://open.win.ox.ac.uk/pages/ndcn0236/fsl-pipe)).
  The GUI can then be started using
  ```python
  pipeline.gui(file_tree)
  ```

  This GUI consists of 3 parts, which will be presented to the user in sequence:
  1. An interactive table, where the default values for placeholders (e.g., subject or session id) can be overwritten.
  2. A visualisation of the `file_tree` on the left. For the template selected on the left, the matching filenames are shown on the right. If you want the pipeline to produce a specific file, simply click on the row to mark the checkbox. Files without a checkbox cannot be produced by this pipeline. If the checkbox has been replaced by an "M" then the file cannot be produced due to a missing input file. Filenames in blue already exist (but can be produced by the pipeline anyway if it has a checkbox).
  3. A summary of which files are requested and which jobs will actually be run. If the user confirms this summary then the pipeline will actually run.

rpm_license:
  MIT License  Copyright (c) 2023 Michiel Cottaar, University of Oxford  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: 3101b3e0ed024cde45c815a9de3893b6b439dd7457b4859d7f172abe9fe80a4e
name: python-fsl-pipe-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for fsl-pipe
url: https://git.fmrib.ox.ac.uk/fsl/fsl-pipe
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fsl-pipe-1.1.2-1.src.rpm
location_href: Packages/python-fsl-pipe-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation](https://img.shields.io/badge/Documentation-fsl--pipe-blue)](https://open.win.ox.ac.uk/pages/fsl/fsl-pipe)
  [![File-tree Documentation](https://img.shields.io/badge/Documentation-file--tree-blue)](https://open.win.ox.ac.uk/pages/fsl/file-tree)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.6577069.svg)](https://doi.org/10.5281/zenodo.6577069)
  [![Pipeline status](https://git.fmrib.ox.ac.uk/fsl/fsl-pipe/badges/main/pipeline.svg)](https://git.fmrib.ox.ac.uk/fsl/fsl-pipe/-/pipelines/latest)
  [![Coverage report](https://git.fmrib.ox.ac.uk/fsl/fsl-pipe/badges/main/coverage.svg)](https://open.win.ox.ac.uk/pages/fsl/fsl-pipe/htmlcov)

  Declarative pipelines based on Filetrees. A pipeline is defined by:
  - A file-tree, which defines the directory structure of the inputs and outputs of the pipeline. A tutorial on these file-trees is available [here](https://open.win.ox.ac.uk/pages/fsl/file-tree).
  - A set of recipes describing how all the pipeline outputs are produced. A tutorial on writing these recipes is available [here](https://open.win.ox.ac.uk/pages/fsl/fsl-pipe).
  Fsl-pipe will stitch these recipes together to produce any user-selected output files.
  Resulting jobs will either run locally, run distributed using [dask](https://www.dask.org), or be submitted to a cluster using [fsl-sub](https://git.fmrib.ox.ac.uk/fsl/fsl_sub).

  An example diffusion MRI pipeline using fsl-pipe with detailed comments is available [here](https://git.fmrib.ox.ac.uk/ndcn0236/fsl-pipe-example).


  ```shell
  pip install fsl-pipe
  ```

  Any bug reports and feature requests are very welcome (see [issue tracker](https://git.fmrib.ox.ac.uk/fsl/fsl-pipe/-/issues)).


  This package uses [uv](https://docs.astral.sh/uv/) for project management.
  You will need to install uv to develop this package.

  First clone the repository:
  ```shell
  git clone https://git.fmrib.ox.ac.uk/fsl/fsl-pipe.git
  ```

  Then we can ask uv to set up the local envoriment.
  ```shell
  cd fsl-pipe
  uv sync
  ```


  Tests are run using the [pytest](https://docs.pytest.org) framework.
  This will already be available in the `uv` virtual environment.
  ```shell
  uv run pytest src/tests
  ```


  The documentation is build using [sphinx](https://www.sphinx-doc.org/en/master/).
  ```shell
  cd doc
  uv run sphinx-build source build
  open build/index.html
  ```


  [Merge requests](https://git.fmrib.ox.ac.uk/fsl/fsl-pipe/-/merge_requests) with any bug fixes or documentation updates are always welcome.

  For new features, please raise an [issue](https://git.fmrib.ox.ac.uk/fsl/fsl-pipe/-/issues) to allow for discussion before you spend the time implementing them.


  - Ensure CHANGELOG.md is up to date.
  - Edit the version number on `pyproject.toml`
  - Create a new tag for the version number
  - Push to gitlab (including tags).
      - The pipeline from the tag will automatically publish fsl-pipe to [pypi](https://pypi.org/project/fsl-pipe/).
  - Upload code on conda-forge using their automated release detection.

rpm_license:
  MIT License  Copyright (c) 2022 Michiel Cottaar, University of Oxford  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: 8fa237b186cac6f7c763c7e32e6ac536aee9cd2ee19d37559002b7c848dae9c3
name: python-fspacker-help
arch: noarch
version: 0.4.7
epoch: 0
release: 1
summary: Development documents and examples for fspacker
url: https://pypi.org/project/fspacker/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fspacker-0.4.7-1.src.rpm
location_href: Packages/python-fspacker-help-0.4.7-1.noarch.rpm
checksum_type: sha256
description:
  Fast & Simple Packer toolset for python.



  - [x] 10-100x faster than existing deploy libs such as Py2exe, PyInstaller, Nuitka...
  - [ ] Supports multi-project deployment
  - [ ] Supports archiving with zip or 7z
  - [ ] Supports depleyment with InnoSetup
  - [ ] Supports compilation with nuitka
  - [ ] Supports encryption with pyarmor



  - [x] Windows 7 ~ 11
  - [ ] linux
  - [ ] macOS



  - [x] tkinter(Windows only)
  - [x] pyside2
  - [x] matplotlib
  - [x] pandas
  - [x] pytorch



  Usage:

  ```bash
  pip install fspacker
  cd [directory/of/app.py]
  fsp
  ```

  > **!!!NOTICE!!!**
  > 'app.py' must contain 'main' function as entry.

  Example:

  Python project structure:

  ```bash
  ex01_helloworld_console/
  |___ modules/
      |____ __init__.py
      |____ module_a.py
      |____ module_b.py
  |___ ex01_helloworld_console.py
  |___ module_c.py

  ```

  ```python

  from modules.module_a import function_a  # import from
  from modules.module_b import function_b  # import from
  import module_c  # import


  def main():
      print("hello, world")

      function_a()
      function_b()
      module_c.function_c()
  ```

  Run command:

  ```bash
  cd .../ex01_helloworld_console
  fsp
  ```


pkgId: 34acc520e5be50431990e48d59daab16d632c9091402ca556d016cd08942a6c3
name: python-fspacker-help
arch: noarch
version: 0.5.6
epoch: 0
release: 1
summary: Development documents and examples for fspacker
url: https://pypi.org/project/fspacker/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fspacker-0.5.6-1.src.rpm
location_href: Packages/python-fspacker-help-0.5.6-1.noarch.rpm
checksum_type: sha256
description:
  Fast & Simple Packer toolset for python.



  - [x] 10-100x faster than existing deploy libs such as Py2exe, PyInstaller, Nuitka...
  - [x] Supports multi-project deployment
  - [ ] Supports archiving with zip or 7z
  - [ ] Supports deployment with InnoSetup
  - [ ] Supports compilation with nuitka
  - [ ] Supports encryption with pyarmor



  - [x] Windows 7 ~ 11
  - [ ] linux
  - [ ] macOS



  - [x] tkinter(Windows only)
  - [x] pyside2
  - [x] matplotlib
  - [x] pandas
  - [x] pytorch



  Usage:

  ```bash
  pip install fspacker
  cd [directory/of/app.py]
  fsp
  ```

  > **!!!NOTICE!!!**
  > 'app.py' must contain 'main' function as entry.

  Example:

  Python project structure:

  ```bash
  ex01_helloworld_console/
  |___ modules/
      |____ __init__.py
      |____ module_a.py
      |____ module_b.py
  |___ ex01_helloworld_console.py
  |___ module_c.py

  ```

  ```python

  from modules.module_a import function_a  # import from
  from modules.module_b import function_b  # import from
  import module_c  # import


  def main():
      print("hello, world")

      function_a()
      function_b()
      module_c.function_c()
  ```

  Run command:

  ```bash
  cd .../ex01_helloworld_console
  fsp
  ```


pkgId: e9c2b9c6cd743ebdad9b5ef5c55aa925eb3b474fca41209a12609c3155effc3a
name: python-fsrs-help
arch: noarch
version: 4.1.1
epoch: 0
release: 1
summary: Development documents and examples for fsrs
url: https://github.com/open-spaced-repetition/py-fsrs
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fsrs-4.1.1-1.src.rpm
location_href: Packages/python-fsrs-help-4.1.1-1.noarch.rpm
checksum_type: sha256
description:
  You can install the `fsrs` python package from [PyPI](https://pypi.org/project/fsrs/) using pip:
  ```
  pip install fsrs
  ```

  Import and initialize the FSRS scheduler
  ```python
  from fsrs import Scheduler, Card, Rating, ReviewLog
  scheduler = Scheduler()
  ```
  Create a new Card object
  ```python

  card = Card()
  ```
  Choose a rating and review the card with the scheduler
  ```python




  rating = Rating.Good
  card, review_log = scheduler.review_card(card, rating)
  print(f"Card rated {review_log.rating} at {review_log.review_datetime}")

  ```
  See when the card is due next
  ```python
  from datetime import datetime, timezone
  due = card.due

  time_delta = due - datetime.now(timezone.utc)
  print(f"Card due on {due}")
  print(f"Card due in {time_delta.seconds} seconds")


  ```


  You can initialize the FSRS scheduler with your own custom parameters.
  ```python
  from datetime import timedelta

  scheduler = Scheduler(
      parameters = (
              0.40255,
              1.18385,
              3.173,
              15.69105,
              7.1949,
              0.5345,
              1.4604,
              0.0046,
              1.54575,
              0.1192,
              1.01925,
              1.9395,
              0.11,
              0.29605,
              2.2698,
              0.2315,
              2.9898,
              0.51655,
              0.6621,
          ),
      desired_retention = 0.9,
      learning_steps = (timedelta(minutes=1), timedelta(minutes=10)),
      relearning_steps = (timedelta(minutes=10),),
      maximum_interval = 36500,
      enable_fuzzing = True
  )
  ```

  `parameters` are a set of 19 model weights that affect how the FSRS scheduler will schedule future reviews. If you're not familiar with optimizing FSRS, it is best not to modify these default values.
  `desired_retention` is a value between 0 and 1 that sets the desired minimum retention rate for cards when scheduled with the scheduler. For example, with the default value of `desired_retention=0.9`, a card will be scheduled at a time in the future when the predicted probability of the user correctly recalling that card falls to 90%. A higher `desired_retention` rate will lead to more reviews and a lower rate will lead to fewer reviews.
  `learning_steps` are custom time intervals that schedule new cards in the Learning state. By default, cards in the Learning state have short intervals of 1 minute then 10 minutes. You can also disable `learning_steps` with `Scheduler(learning_steps=())`
  `relearning_steps` are analogous to `learning_steps` except they apply to cards in the Relearning state. Cards transition to the Relearning state if they were previously in the Review state, then were rated Again - this is also known as a 'lapse'. If you specify `Scheduler(relearning_steps=())`, cards in the Review state, when lapsed, will not move to the Relearning state, but instead stay in the Review state.
  `maximum_interval` sets the cap for the maximum days into the future the scheduler is capable of scheduling cards. For example, if you never want the scheduler to schedule a card more than one year into the future, you'd set `Scheduler(maximum_interval=365)`.
  `enable_fuzzing`, if set to True, will apply a small amount of random 'fuzz' to calculated intervals. For example, a card that would've been due in 50 days, after fuzzing, might be due in 49, or 51 days.

  **Py-FSRS uses UTC only.**
  You can still specify custom datetimes, but they must use the UTC timezone.

  You can calculate the current probability of correctly recalling a card (its 'retrievability') with
  ```python
  retrievability = card.get_retrievability()
  print(f"There is a {retrievability} probability that this card is remembered.")

  ```

  `Scheduler`, `Card` and `ReviewLog` objects are all JSON-serializable via their `to_dict` and `from_dict` methods for easy database storage:
  ```python

  scheduler_dict = scheduler.to_dict()
  card_dict = card.to_dict()
  review_log_dict = review_log.to_dict()

  new_scheduler = Scheduler.from_dict(scheduler_dict)
  new_card = Card.from_dict(card_dict)
  new_review_log = ReviewLog.from_dict(review_log_dict)
  ```

  Card objects have one of three possible states
  ```python
  State.Learning # (==1) new card being studied for the first time
  State.Review # (==2) card that has "graduated" from the Learning state
  State.Relearning # (==3) card that has "lapsed" from the Review state
  ```
  There are four possible ratings when reviewing a card object:
  ```python
  Rating.Again # (==1) forgot the card
  Rating.Hard # (==2) remembered the card with serious difficulty
  Rating.Good # (==3) remembered the card after a hesitation
  Rating.Easy # (==4) remembered the card easily
  ```

  You can find various other FSRS implementations and projects [here](https://github.com/orgs/open-spaced-repetition/repositories?q=fsrs+sort%3Astars).

  The following spaced repetition schedulers are also available as python packages:
  - [SM-2](https://github.com/open-spaced-repetition/sm-2)
  - [Leitner System](https://github.com/open-spaced-repetition/leitner-box)
  - [Anki Default Scheduler](https://github.com/open-spaced-repetition/anki-sm-2)

  Checkout [CONTRIBUTING](CONTRIBUTING.md) to help improve Py-FSRS!

rpm_license:
  MIT License  Copyright (c) 2022 Open Spaced Repetition  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: 5d917888c06c0bb55b337f0384ab0574562a46a45c2ad5b24a1bfab7a7361de5
name: python-fstrent-bkitup-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for fstrent-bkitup
url: https://github.com/wrm3/fstrent_bkitup
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fstrent-bkitup-0.1.4-1.src.rpm
location_href: Packages/python-fstrent-bkitup-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  A Python utility for creating timestamped backups of Python scripts and projects.



  ```bash
  pip install fstrent_bkitup
  ```





  Place this at the very top of your script, right after your imports:

  ```python

  import sys
  import os


  from fstrent_bkitup import backup_script


  backup_script(__file__)


  def main():
      
      pass

  if __name__ == "__main__":
      main()
  ```



  For backing up multiple files or entire directories, use backup_project:

  ```python

  import sys
  import os


  from fstrent_bkitup import backup_project


  backup_project(
      __file__,  # current script
      additional_paths=[
          'lib',           # backup entire lib directory
          'config.json',   # backup specific files
          'src'           # backup src directory
      ],
      output_dir='backups'  # where to store the zip files
  )


  def main():
      
      pass

  if __name__ == "__main__":
      main()
  ```



  - Create timestamped backups of individual Python scripts
  - Create ZIP archives of entire projects including specified directories and files
  - Preserve file metadata
  - Configurable output directory



  - Single script backups: `original_name_YYYYMMDD_HHMMSS.py`
  - Project backups: `original_name_YYYYMMDD_HHMMSS.zip`





  ```python
  from fstrent_bkitup import backup_script as bks


  bks(__file__)


  bks(__file__, output_dir='my_backups')
  ```



  ```python
  from fstrent_bkitup import backup_project as bkp


  bkp(
      __file__,
      additional_paths=[
          'lib',
          'config',
          'data/important.csv'
      ]
  )
  ```



  This project is licensed under the MIT License - see the LICENSE file for details.

rpm_license:
  MIT License  Copyright (c) 2024 [Your Name]  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 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: fd6e37aafff735abbde9976a8df1dccbe527898cb908a3376354356ac0b0b8d4
name: python-ftech-pydantic-ai-help
arch: noarch
version: 0.0.12
epoch: 0
release: 1
summary: Development documents and examples for ftech-pydantic-ai
url: https://pypi.org/project/ftech-pydantic-ai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ftech-pydantic-ai-0.0.12-1.src.rpm
location_href: Packages/python-ftech-pydantic-ai-help-0.0.12-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml/badge.svg?event=push)](https://github.com/pydantic/pydantic-ai/actions/workflows/ci.yml?query=branch%3Amain)
  [![Coverage](https://coverage-badge.samuelcolvin.workers.dev/pydantic/pydantic-ai.svg)](https://coverage-badge.samuelcolvin.workers.dev/redirect/pydantic/pydantic-ai)
  [![PyPI](https://img.shields.io/pypi/v/pydantic-ai.svg)](https://pypi.python.org/pypi/pydantic-ai)
  [![versions](https://img.shields.io/pypi/pyversions/pydantic-ai.svg)](https://github.com/pydantic/pydantic-ai)
  [![license](https://img.shields.io/github/license/pydantic/pydantic-ai.svg?v)](https://github.com/pydantic/pydantic-ai/blob/main/LICENSE)

  PydanticAI core logic with minimal required dependencies.

  For more information on how to use this package see [ai.pydantic.dev/install](https://ai.pydantic.dev/install/).


pkgId: 050db7befa693f0def95f1033bdff03087aa8b3822f25b3ea979611bf60f8c8b
name: python-ftui-help
arch: noarch
version: 0.1.10
epoch: 0
release: 1
summary: Development documents and examples for ftui
url: https://github.com/freqtrade/ftui
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ftui-0.1.10-1.src.rpm
location_href: Packages/python-ftui-help-0.1.10-1.noarch.rpm
checksum_type: sha256
description:
  servers:
      - name        : "botA"
        username    : "you"
        password    : "your_password"
        ip          : 1.2.3.4
        port        : 8080
      - name        : "botB"
        username    : "you"
        password    : "your_password"
        ip          : 1.2.3.4
        port        : 8081
      - name        : "botC"
        username    : "you"
        password    : "your_password"
        ip          : 5.6.7.8
        port        : 8080
  colours:
      pair_col: "purple"
      bot_col: "yellow"
      bot_start_col: "white"
      trade_id_col: "white"
      open_rate_col: "white"
      current_rate_col: "white"
      open_date_col: "cyan"
      winrate_col: "cyan"
      open_trade_num_col: "cyan"
      closed_trade_num_col: "purple"
      profit_chart_col: "orange"
      link_col: "yellow"
      candlestick_trade_text_col: "orange"
      candlestick_trade_open_col: "blue"
      candlestick_trade_close_col: "purple"
  debug: False
  show_fear: True
  ```
  Add a corresponding `servers` block into your own `config.yaml`, making note of the
  indentation.
  You can monitor bots across multiple servers easily in one FTUI interface. FTUI uses
  the [freqtrade-client](https://pypi.org/project/freqtrade-client/) REST API client, so
  you do not need to wrestle with any CORS setup as you have to do in FreqUI to access
  multiple bots.
  You can also set custom colours for some of the UI elements as per the example above.
  The supported list of colour names can be found
  [here](https://textual.textualize.io/api/color/#textual.color--named-colors). You can
  leave the `colours` option out of the configuration and defaults will be used.
  In future, the Settings screen will allow configuration of the `config.yaml` from inside the
  FTUI interface.

  Once you have saved your `config.yaml` file, make sure you are in your ftui directory with your
  venv activated, and run FTUI as below. FTUI will load each bot client, and preload trade data
  into memory:
  ```bash
  $ ftui -y config.yaml
  ███████╗████████╗██╗   ██╗██╗
  ██╔════╝╚══██╔══╝██║   ██║██║
  █████╗     ██║   ██║   ██║██║
  ██╔══╝     ██║   ██║   ██║██║
  ██║        ██║   ╚██████╔╝██║
  ╚═╝        ╚═╝    ╚═════╝ ╚═╝
  Freqtrade Textual User Interface (FTUI)
  Run with:
      ftui -y config.yaml
  Setting up botA version 2024.1-dev-1b70e9b07 at http://1.2.3.4:8080: SampleStrategy running dry_run 5m
  Setting up botB version 2024.1-dev-1b70e9b07 at http://1.2.3.4:8081: SampleStrategy running dry_run 5m
  Setting up botC version 2024.1-dev-1b70e9b07 at http://5.6.7.8:8080: SampleStrategy running dry_run 5m
  Starting FTUI - preloading all dataframes.......
  ```

  __Dashboard__
  The main dashboard shows summary statistics from all bots. You can access the dashboard by
  clicking the Dashboard button in the bottom left, or hitting the `D` key.
  ![image](https://github.com/freqtrade/ftui/assets/1872302/53d9e2ca-1afd-4d0d-ace6-a7a5419a0397)
  __View Bots__
  The bot view allows selection of a running bot from the dropdown at the top of the screen.
  Once selected, various information about the bot will be shown in the tabs in the bottom half
  of the screen. You can access the View Bots screen by clicking the button in the bottom left,
  or hitting the `B` key.
  Open trades:
  ![image](https://github.com/freqtrade/ftui/assets/1872302/ac12cf57-2235-4215-9463-8072ef9d9f02)
  Closed trades:
  ![image](https://github.com/freqtrade/ftui/assets/1872302/abdd62ef-f9dc-4eb3-b33e-05e4611141c5)
  Tag summary:
  ![image](https://github.com/freqtrade/ftui/assets/1872302/906f644b-f203-45a3-b821-c7b0d25a01e7)
  Performance:
  ![image](https://github.com/freqtrade/ftui/assets/1872302/16cce9a9-61f0-4caa-98f2-823b57a82ef8)
  General bot information:
  ![image](https://github.com/freqtrade/ftui/assets/1872302/6e597102-59f2-4456-b321-f5ce787ab89d)
  Logs:
  ![image](https://github.com/freqtrade/ftui/assets/1872302/1dcc8b43-7bd4-43ae-907f-0dc749a717ea)
  Sysinfo:
  ![image](https://github.com/freqtrade/ftui/assets/1872302/b1377e21-03f8-47a1-92eb-11b523753ad7)
  __Settings__
  The Settings screen shows the list of configured bots on the left hand side of the screen.
  Other configuration options are shown on the right. You can access the Settings
  screen by clicking the button in the bottom left, or hitting the `S` key.
  In future, you will be able to show and hide bots in FTUI by selecting/deselecting them
  in the bot list, as well as changing other configuration options. Currently this feature
  is disabled in this alpha release.
  __Help__
  This README!


  - When the bot is been running and you put your PC to sleep, the async worker will bug out
    and intermittently crash the UI.
  - The Settings screen save functionality is currently disabled.


pkgId: 1ec51613286c64d811bdbee78bd3923dc9d3d547b52d97e073c1af4205bfb6c9
name: python-fuando-example-stainless-help
arch: noarch
version: 0.0.1a1
epoch: 0
release: 1
summary: Development documents and examples for fuando-example-stainless
url: https://github.com/AndooBomber/example-stainless-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fuando-example-stainless-0.0.1a1-1.src.rpm
location_href: Packages/python-fuando-example-stainless-help-0.0.1a1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/fuando_example_stainless.svg)](https://pypi.org/project/fuando_example_stainless/)

  The Petstore Python library provides convenient access to the Petstore REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [app.stainlessapi.com](https://app.stainlessapi.com/docs). The full API of this library can be found in [api.md](https://github.com/AndooBomber/example-stainless-py/tree/main/api.md).



  ```sh

  pip install --pre fuando_example_stainless
  ```



  The full API of this library can be found in [api.md](https://github.com/AndooBomber/example-stainless-py/tree/main/api.md).

  ```python
  import os
  from example_stainless import Petstore

  client = Petstore(
      api_key=os.environ.get("PETSTORE_API_KEY"),  # This is the default and can be omitted
  )

  order = client.store.create_order(
      pet_id=1,
      quantity=1,
      status="placed",
  )
  print(order.id)
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `PETSTORE_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  Simply import `AsyncPetstore` instead of `Petstore` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from example_stainless import AsyncPetstore

  client = AsyncPetstore(
      api_key=os.environ.get("PETSTORE_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      order = await client.store.create_order(
          pet_id=1,
          quantity=1,
          status="placed",
      )
      print(order.id)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `example_stainless.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `example_stainless.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `example_stainless.APIError`.

  ```python
  import example_stainless
  from example_stainless import Petstore

  client = Petstore()

  try:
      client.store.inventory()
  except example_stainless.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except example_stainless.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except example_stainless.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from example_stainless import Petstore


  client = Petstore(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).store.inventory()
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from example_stainless import Petstore


  client = Petstore(
      
      timeout=20.0,
  )


  client = Petstore(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).store.inventory()
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/AndooBomber/example-stainless-py/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `PETSTORE_LOG` to `info`.

  ```shell
  $ export PETSTORE_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from example_stainless import Petstore

  client = Petstore()
  response = client.store.with_raw_response.inventory()
  print(response.headers.get('X-My-Header'))

  store = response.parse()  # get the object that `store.inventory()` would have returned
  print(store)
  ```

  These methods return an [`APIResponse`](https://github.com/AndooBomber/example-stainless-py/tree/main/src/example_stainless/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/AndooBomber/example-stainless-py/tree/main/src/example_stainless/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.store.with_streaming_response.inventory() as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from example_stainless import Petstore, DefaultHttpxClient

  client = Petstore(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.

  ```py
  from example_stainless import Petstore

  with Petstore() as client:
    
    ...


  ```



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/AndooBomber/example-stainless-py/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import example_stainless
  print(example_stainless.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/AndooBomber/example-stainless-py/tree/main/./CONTRIBUTING.md).


pkgId: 5bd1e5cc5c116abf215c3ff1c06e9091249a33ece2fc03310600021f00403fae
name: python-fudster-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for fudster
url: https://pypi.org/project/fudster/
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fudster-1.0.3-1.src.rpm
location_href: Packages/python-fudster-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  A python library that helps with mL application development through using REST/WebSockets.




  These are notes for the development of the Fudster package.
  The docker image is released under `kbve/fudster`.
  Next update was the malloc changes and memory changes.



  Here is the shell command to add a new package to the fudster package within the nx monorepo.

  ```shell

  pnpm nx run fudster:add --name aiohttp
  pnpm nx run fudster:add --name signalrcore

  ```



  To build the base docker image and then run it:

  ```shell

  ./kbve.sh -nx fudster:orb

  ```

  or to run them isolated:

  ```shell

  pnpm nx container fudster
  docker run -p 3000:3000 -p 3001:3001 -p 8086:8086 kbve/fudster:1.03

  ```



  This is just for test casing the different commands that would be sent.
  For world



  World Switching

  ```json

      {
              "channel": "default",
              "content": {
                  "command": "execute",
                  "packageName": "net.runelite.client.plugins.microbot.kbve",
                  "className": "KBVEScripts",
                  "method": "AcceptEULA",
                  "args": [300, 301],
                  "priority": 1
              }
      }

  ```

  Login

  ```json

      {
          "channel": "default",
          "content": {
                  "command": "login",
                  "username": "myUsername",
                  "password": "myPassword",
                  "bankpin": "0000",
                  "world": "301"
              }
      }

  ```



  ```json

      {
              "channel": "default",
              "content": {
                  "command": "execute",
                  "packageName": "net.runelite.client.plugins.microbot.kbve",
                  "className": "KBVEScripts",
                  "method": "AcceptEULA",
                  "args": [300, 301],
                  "priority": 1
              }
      },

      {
              "channel": "default",
              "content": {
                  "command": "execute",
                  "packageName": "net.runelite.client.plugins.microbot.util.security",
                  "className": "Login",
                  "method": "setWorld",
                  "args": [308],
                  "priority": 1
              }
      },

      {
          "channel": "default",
          "content": {
                  "command": "execute",
                  "packageName": "net.runelite.client.plugins.microbot.kbve",
                  "className": "KBVEScripts",
                  "method": "SafeLogin",
                  "args": ["myUsername", "myPassword", "0000", 301],
                  "priority": 1
              }
      },

      {
          "channel": "default",
          "content": {
                  "command": "login",
                  "username": "myUsername",
                  "password": "myPassword",
                  "bankpin": "0000",
                  "world": "301"
              }
      }

  ```


pkgId: c0951377ce1a0bd79a0725e66512272ba866b59e37f62b9bfcb4287b540468e2
name: python-funcnodes-basic-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for funcnodes-basic
url: https://pypi.org/project/funcnodes-basic/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-funcnodes-basic-0.2.0-1.src.rpm
location_href: Packages/python-funcnodes-basic-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  `funcnodes-basic` is a collection of essential nodes designed to handle fundamental operations in [Funcnodes](https://github.com/linkdlab/funcnodes), such as list manipulation, dictionary operations, logic control, mathematical functions, and string processing. It provides a foundation of commonly needed functionalities in computational graphs built with the FuncNodes framework. Each module within this package contains a set of nodes, grouped by their operation type, allowing seamless integration into broader systems.



  Install the package with:

  ```bash
  pip install funcnodes-basic
  ```



  Please refere to the [Funcnodes](https://github.com/linkdlab/funcnodes) package



  You can integrate the provided nodes in your computational graphs, connecting inputs and outputs between nodes to build complex workflows that utilize dictionaries, lists, logic, math, and string operations.



  Feel free to contribute to this project by submitting pull requests. You can help by adding new nodes, fixing bugs, or enhancing documentation.



  This project is licensed under the MIT License.



  For any questions or issues, please open an issue on the GitHub repository.


pkgId: 8fe19ba93e296e04b36be2e63751bcfdc68b3b689e3012d89e2ee40199f88217
name: python-functional-maybe-help
arch: noarch
version: 1.1.8
epoch: 0
release: 1
summary: Development documents and examples for functional-maybe
url: https://github.com/JoonasOT/FunctionalMaybe/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-functional-maybe-1.1.8-1.src.rpm
location_href: Packages/python-functional-maybe-help-1.1.8-1.noarch.rpm
checksum_type: sha256
description:
  A simple Maybe wrapper class that works. Creates a wrapper around variable and allows transformation of said variable to different values and supplying it to functions.



  ```Python
  import sys
  from FunctionalMaybe import FunctionalMaybe as Maybe

  joined = Maybe(["one", "two", "three"])\
          .transform(lambda list_: ", ".join(list_))\  # Transform the values to something with lambda
          .run(lambda result: print(result))\          # Run functions with the contained value
          .unwrap()                                    # Return the wrapped value


  if isinstance(joined, Maybe.Empty):
      print(str(joined), file=sys.stderr)

  ```

  Also supports calling the constructure inside the Maybe-class, which enables error handling via Maybe.Empty:
  ```Python
  from FunctionalMaybe import FunctionalMaybe as Maybe

  class Foo:
      def __init__(self, x, y, z=None, w=1):
          self.x = x
          self.y = y
          self.z = z
          self.w = w

      def __str__(self):
          return f"{self.x}, {self.y}, {self.z}, {self.w}"

  def log(val):
      print(val)

  Maybe().construct(Foo, 1, "one", w=4).transform(lambda foo: str(foo)).run(log)

  Maybe("one").construct(Foo, 1, Maybe.Unwrapper, w=4).transform(lambda foo: str(foo)).run(log)


  ```


pkgId: e699271875d171d10e56a6a368bcded6b56dd4540d3560d47152e8cd48436b65
name: python-funding-service-design-utils-help
arch: noarch
version: 5.3.1
epoch: 0
release: 1
summary: Development documents and examples for funding-service-design-utils
url: https://github.com/communitiesuk/funding-service-design-utils
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-funding-service-design-utils-5.3.1-1.src.rpm
location_href: Packages/python-funding-service-design-utils-help-5.3.1-1.noarch.rpm
checksum_type: sha256
description:
      applications:
          command: gunicorn wsgi:app -c run/gunicorn/devtest.py

  The logging utility formats logs to a consistent format (text in development and json in other environments).
  The utility also supports logging from gunicorn
  To use it add the following to your flask create_app factory
      from fsd_utils.logging import logging
      def create_app():
          
          logging.init_app(flask_app)
  and in your env config classes, specify the log level you want to report eg.:
      @configclass
      class DefaultConfig(object):
          
          FSD_LOG_LEVEL = logging.WARNING

  The authentication utility provides a consistent authentication functions including a `@login_required` decorator that can be used to restrict routes that should only be accessible to authenticated users.
  To use the utility:
  First - ensure that the following environment variables are set to the appropriate values eg.:
      FSD_USER_TOKEN_COOKIE_NAME = "fsd_user_token"
      AUTHENTICATOR_HOST = "https://funding-service-design-authenticator-dev.london.cloudapps.digital"
      RSA256_PUBLIC_KEY = "{RSA PUBLIC KEY}"
  NOTE: These values (and keys) need to be shared/common across all microservices that use each common authenticator host. If any of the environment *keys* for each of these attributes needs to be modified these can be reconfigured in fsd_utils/authentication/config.py.
  To generate new keys in your cwd, you use the following commands:
  ```bash
  openssl genrsa -out private_key.pem 2048
  openssl rsa -pubout -in private_key.pem -out public_key.pem
  ```
  If you're changing keys, you'll need to change them in GitHub secrets across repos.
  Please also add them to BitWarden and let the team know.
  Then - to use the `@login_required` decorator just add it to routes you need to protect eg:
      
      from fsd_utils.authentication.decorators import login_required
      @login_required
      def example_route(account_id):
          
          

  Adds the route `/healthcheck` to an application. On hitting this endpoint, a customisable set of checks are run to confirm the application is functioning as expected and a JSON response is returned.
  Response codes:
  - 200: All checks were successful, application is healthy
  - 500: One or more checks failed, application is unhealthy
  Example usage:
  ```
  from fsd_utils.healthchecks.healthcheck import Healthcheck
  from fsd_utils.healthchecks.checkers import DbChecker, FlaskRunningChecker
  health = Healthcheck(flask_app)
  health.add_check(FlaskRunningChecker())
  health.add_check(DbChecker(db))
  ```
  The above will initialise the `/healthcheck` url and adds 2 checks.

  The following 2 checks are provided in `fsd_utils` in `checkers.py`:
  - `FlaskRunningChecker`: Checks whether a `current_app` is available from flask, returns `True` if it is, `False` if not.
  - `DbChecker`: Runs a simple query against the DB to confirm database availability.

  Custom checks can be created as subclasses of `CheckerInterface` and should contain a method with the following signature:
  `def check(self) -> Tuple[bool, str]:`
  Where
  - `bool` is a True or False whether the check was successful
  - `str` is a message to display in the result JSON, typically `OK` or `Fail`

  Multiple language support is provided by `flask-babel`. Docs here: https://python-babel.github.io/flask-babel/#

  The python setup relies on 2 methods and an initialisation. In `create_app` we initialise `babel` on our app:
      from fsd_utils.locale_selector.get_lang import get_lang
      babel = Babel(flask_app)
      babel.locale_selector_func = get_lang
      LanguageSelector(flask_app)
  The `get_lang()` function reads the user-selected language from a cookie (if set by `LanguageSelector` - see below), or if that is not present uses a built-in function of babel to negotiate the language based on the request headers and the supported languages.
  `LanguageSelector` creates an additional route `/language/<language>` that sets the user's selected language in a cookie. Used the cookie rather than the session so it can be shared across the microservices.
  Set `COOKIE_DOMAIN` on the app to the domain you want to set the cookie on.

  1. Add `trans` tags around items in your jinja html file that you want to translate. What's contained in the `trans` tag should be the english version of this text. eg:
          A greeting is: {% trans %}Good Morning{% endtrans %}
  1. Generate a new translations template file (`messages.pot`)
          pybabel extract -F babel.cfg -o messages.pot .
  1. If initialising a new set of translations for a new repo or adding a new language, use `init`. *This will override any changes already made in the `translations` directory!*
          
          pybabel init -i messages.pot -d app/translations -l cy
      The directory supplied to `-d` (eg. `app/translations`) must sit at the same level as the `templates` folder, in our case within the `app` directory. This command generates a new `messages.po` file in `translations/cy/LC_MESSAGES/` Where `cy` is the language code. (cy = Welsh/Cymraeg)
  1. If you've added new strings to an existing template, or added new templates after running `init`, use `update`:
          pybabel update -i messages.pot -d app/translations
      This will append new strings to the existing `messages.po` file, preserving any translations you already have in there.
  1. To add translations for strings, edit the `messages.po` file.
          
          msgid "Good Morning"
          msgstr "Bore da"
      where `msgid` is the english version of the string from the original template file, and `msgstr` is the translation of the string.
  1. Once the translations are ready, use `compile` to generate the binary for use at runtime:
          pybabel compile -d app/translations

  Enables Sentry integration.
  * Before the flask app is created initialise Sentry using
  ```
  from fsd_utils import init_sentry
  init_sentry()
  ```
  * Set the `SENTRY_DSN` environment variable on the app

  Folder to hold miscellaneous simple utilities.

  Date comparison functions that accept an ISO Format string, for use in the frontend determining display logic based on dates.

  Contains shared fixtures that can be used for unit tests in other repos. To include a fixture from `fsd_utils` in your project, add the following to your `conftest.py`:
      pytest_plugins = ["fsd_test_utils.fixtures.db_fixtures"]
  Where the part inside `[]` is the paths to the python files you want to load as fixtures.

  Individual fixtures are explained below, but this is the general expected usage. In the `conftest.py` of your repo, define a fixture that will seed the database with the test data you require and make those records avaialble to tests. That fixture should request `clear_test_data` and `enable_preserve_test_data` to prevent test pollution and ensure a suitable database is available for tests. The tests themselves should only update data that is inserted by that fixture. Examples:
  1. Basic Usage
      In conftest.py
          @pytest.fixture(scope="function")
          def create_test_data(clear_test_data, enable_preserve_test_data):
              
              created_data = [all_created_data]
              yield created_data
              
      In your test file
          def test_get_data(create_test_data):
              id = create_test_data[0].id
              record = get_record_using_api_under_test(id)
              assert record.id == id
  1. If your tests need to directly manipulate the database, use the `_db` fixture:
          def test_after_update(create_test_data, _db):
              id = create_test_data[0].id
              record = get_record(id)
              record.name = "new name"
              _db.session.add(record)
              _db.session.commit()
              
  1. If you want to be able to inspect the database after running a test:
          @pytest.mark.preserve_test_data(True)
          def test_get_data(create_test_data):
              id = create_test_data[0].id
              record = get_record_using_api_under_test(id)
              assert record.id == id
      After the test runs, any created data will still be there for manual inspection. It will then be removed at the start of the next test run.

  This fixture is module scoped so at the end of each test file all data is removed from the database (providing `preserve_test_data` is not set - see below.) Helps to prevent test pollution.

  This fixture looks for the marker `pytest.mark.preserve_test_data(True)` and if found, test data is not cleared at the end of the test session, allowing you to manually inspect the database to aid debugging.
  **Note**: Not intended to be used as a default for tests as it can lead to test pollution, so only use to debug and then remove again.

  Provides direct access to the database for tests. Useful if your test needs to explicitly insert/update records to prepare test data.

  This fixture reads the pytest cache to determine whether the DB can be reused for this test run and then the db is recreated accordingly. Updates the cache value to enable reuse of the DB for future test runs. This is session scoped so the DB is not recreated for each test in a run.
  This is requested by `clear_test_data` so you do not need to include it separately in your project if using that fixture.

  The mapping feature serves the purpose of mapping and formatting the questions and answers of the application into a text file. This functionality is utilised in the following scenarios:
  - Within the assessment service, it facilitates the downloading of the application's questions and answers.
  - In the notification service, it enables the posting of the applicant's application answer.
  To accomplish the mapping of the application's questions and answers, import
      from fsd_utils import extract_questions_and_answers
  To format the questions and answers of the application into a text file, import
      from fsd_utils import generate_text_of_application

rpm_license:
  MIT License  Copyright (c) 2022 Crown Copyright (Department for Levelling Up, Housing and Communities)  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: b60213a26137256bfeb8c71b39229b9fdd9622d6564903d2555cf68ea77c4ad2
name: python-fundrive-help
arch: noarch
version: 1.2.64
epoch: 0
release: 1
summary: Development documents and examples for fundrive
url: https://pypi.org/project/fundrive/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fundrive-1.2.64-1.src.rpm
location_href: Packages/python-fundrive-help-1.2.64-1.noarch.rpm
checksum_type: sha256
description:
  感谢您使用统一云存储接口！我们希望这个工具能够简化您的云存储集成工作。

  百度云盘的 python-api，[官方 API](https://openapi.baidu.com/wiki/index.php?title=docs/pcs/rest/file_data_apis_list)
  蓝奏云的 python-api [参考](https://github.com/zaxtyson/LanZouCloud-API)


pkgId: c55fffd9757964997c43788077cce32ae203546db1c3ed40874481e3d58aaef0
name: python-funfile-help
arch: noarch
version: 1.0.13
epoch: 0
release: 1
summary: Development documents and examples for funfile
url: https://pypi.org/project/funfile/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-funfile-1.0.13-1.src.rpm
location_href: Packages/python-funfile-help-1.0.13-1.noarch.rpm
checksum_type: sha256
description:
  ```python
  pip install funfile
  ```





  ```python
  from funfile import tarfile

  with tarfile.open("results.tar", "w|xz") as tar:
      tar.add("a.txt")


  with tarfile.open("results.tar", "r|xz") as tar:
      tar.extractall("local")
  ```



  ```python
  from funfile import ConcurrentFile
  with ConcurrentFile("a.txt", mode='w') as fw:
      fw.write("hello,funfile.")
  ```


pkgId: 31396fa780899220d5705df98ddf3385448377ec3cad401542d2c36db04d3c47
name: python-funget-help
arch: noarch
version: 1.0.25
epoch: 0
release: 1
summary: Development documents and examples for funget
url: https://pypi.org/project/funget/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-funget-1.0.25-1.src.rpm
location_href: Packages/python-funget-help-1.0.25-1.noarch.rpm
checksum_type: sha256
description:
  ```python
  pip install funget
  ```





  ```
  funget http://dail-wlcb.oss-cn-wulanchabu.aliyuncs.com/dj-competition/eval_data/challenge-data.tar.gz
  ```



  ```python
  from funget import multi_thread_download
  multi_thread_download(url="http://dail-wlcb.oss-cn-wulanchabu.aliyuncs.com/dj-competition/eval_data/challenge-data.tar.gz")
  ```

  ![wget](https://cloud.tencent.com/developer/article/1398383)


pkgId: 6ef2d2324729947aca99db4d40150a1ff4dcce4684ffa4f0cd5217c69a5d623c
name: python-furthrmind-help
arch: noarch
version: 0.1.13
epoch: 0
release: 1
summary: Development documents and examples for furthrmind
url: https://furthrmind.com
rpm_license: GNU GENERAL PUBLIC LICENSE Version 3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-furthrmind-0.1.13-1.src.rpm
location_href: Packages/python-furthrmind-help-0.1.13-1.noarch.rpm
checksum_type: sha256
description:
  This package provides a simple and user-friendly way to interact with your FURTHRmind application. It enables users to
  effortlessly retrieve existing data or write new data into the application.



  You can conveniently install `furthrmind` from PyPi using the following command:
  ```
  pip install furthrmind
  ```





  To initiate an interaction with your server through the Furthrmind class, you need to create an instance of it. You will
  pass in your server's URL and API key. Don’t forget to provide the name or ID of the project you want to work with.

  ```
  from furthrmind import Furthrmind
  fm = FURTHRmind(host, api_key, project_name="my project")
  ```

  Retrieving data necessitates the importation of the relevant collection class. This can be attained either from your
  Furthrmind instance or by direct import.

  ```
  Experiment = fm.Experiment
  from furthrmind.collection import Experiment
  ```

  To fetch a specific experiment, invoke the get method of the Experiment class, passing in the desired experiment's ID.

  ```
  exp = fm.Experiment.get(exp_id)
  ```

  or

  ```
  exp = Experiment.get(exp_id)
  ```

  Both these commands are identical provided the Experiment class was previously imported.

  You can fetch all the experiments from a project by calling the get_all method which returns a list of instances of the
  Experiment class.

  ```
  exp_list = Experiment.get_all()
  ```

  The Experiment class instance encapsulates all data pertinent to your experiment. For convenience, this class provides
  several methods including: add_field, add_many_fields, remove_field, update_field_value, update_field_unit, add_file,
  remove_file, and add_datatable. Details about the available methods for each collection class can be found below.



  In the preceding example, we retrieved one or more experiments from the Furthrmind server. Each experiment encompasses
  various attributes such as the corresponding samples, research items, and the group to which it belongs. Note that these
  entities are nested objects.

  For instance, the 'groups' attribute comprises a list of group instances belonging to the group collection class. To
  optimize network traffic, these nested objects do not load completely. In other words, all properties, except for the '
  id' and 'name', remain unretrieved.

  To verify whether an object has been fully loaded, you can inspect the `_fetched` attribute of the object. If an object
  hasn't been fetched yet, you can invoke the `get()` method on that object to retrieve it.


  The targeted experiment contains an attribute known as 'fielddata', which is a list comprising [FieldData](fielddata.md)
  objects. Unlike [Field](field.md) objects that represent field definitions within a project,
  [FieldData](fielddata.md) merges these definitions with a specific value and unit applicable
  to a particular item, such as an experiment.

  If you wish to locate a field value related to a specific item, you can iterate through the 'fielddata' list and
  compare the field names. For example, to search for the value of a field named "width", you could do the following:
  ```
  for fielddata in exp.fielddata:
      if fielddata.field_name == "width":
          value = fielddata.value
  ```



  To generate a new experiment, you should invoke the `create()` or `create_many()` method. It's important to correctly
  supply the input arguments suitable for each collection class. Specifically, the `create` method of the `Experiment`
  class necessitates passing the new experiment's name, and the name or ID of the group to which it should belong.

  In case your requirement entails adding an experiment to a subgroup, supplying this subgroup's ID becomes paramount.
  The `create` method subsequently gives back an instance of the `Experiment` class, whereas the `create_many` method
  yields a list of `Experiment` class instances.

  ```
  new_exp = Experiment.create("myexperiment2", group_name="My group"
  ```

  Alternatively, to create multiple experiments:

  ```
  experiments = Experiment.create_many([{"name": "exp1", "group": "group1"}, {"name": "exp2", "group": "group2"}])

  ```



  After you created the new experiment you might want to add some fields, files, and datatables to your
  experiment. This can be achieved with:

  ```
  new_exp.add_field(field_name="My field namy", field_type="Numeric",
                    value=5, unit="cm")
  new_exp.add_many_fields([
          {
              "name": "May field name,
              "field_type" ="Numeric",
              "value: 5,
              "unit": "cm"
          },
          {
              "name": "May second field name,
              "field_type" ="Numeric",
              "value: 10,
              "unit": "m"
          }
  ])
  new_exp.add_file(my_file_path)
  new_exp.add_datatable(name=my data table, columns=[
          {
              "name": "my 1st column"
              "type": "Numeric,
              "unit": "cm",
              "data": [1,2,3]
          },
          {
              "name": "my 2nd column"
              "type": "Numeric,
              "unit": "cm",
              "data": [4,5,6]
          },
  ])
  ```



  - [Project](project.md)
  - [Group](group.md)
  - [Experiment](experiment.md)
  - [Sample](sample.md)
  - [ResearchItem](researchitem.md)
  - [File](file.md)
  - [Field](field.md)
  - [FieldData](fielddata.md)
  - [DataTable](datatable.md)
  - [Column](column.md)
  - [ComboBoxEntry](comboboxentry.md)
  - [Unit](unit.md)
  - [Category](category.md)


pkgId: bafc876c233bdc989b4c245445634bf4796f44011b267d711a15c15f2b6088ab
name: python-fusion-bench-help
arch: noarch
version: 0.2.7
epoch: 0
release: 1
summary: Development documents and examples for fusion-bench
url: https://github.com/tanganke/fusion_bench
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fusion-bench-0.2.7-1.src.rpm
location_href: Packages/python-fusion-bench-help-0.2.7-1.noarch.rpm
checksum_type: sha256
description:
  <div align='center'>



  [![arXiv](https://img.shields.io/badge/arXiv-2406.03280-b31b1b.svg)](http://arxiv.org/abs/2406.03280)
  [![GitHub License](https://img.shields.io/github/license/tanganke/fusion_bench)](https://github.com/tanganke/fusion_bench/blob/main/LICENSE)
  [![PyPI - Version](https://img.shields.io/pypi/v/fusion-bench)](https://pypi.org/project/fusion-bench/)
  [![Downloads](https://static.pepy.tech/badge/fusion-bench/month)](https://pepy.tech/project/fusion-bench)
  [![Static Badge](https://img.shields.io/badge/doc-mkdocs-blue)](https://tanganke.github.io/fusion_bench/)
  [![Static Badge](https://img.shields.io/badge/code%20style-black-black)](https://github.com/psf/black)
  [![Static Badge](https://img.shields.io/badge/code%20style-yamlfmt-black)](https://github.com/google/yamlfmt)

  </div>

  > [!TIP]
  > Documentation is available at [tanganke.github.io/fusion_bench/](https://tanganke.github.io/fusion_bench/).



  FusionBench is a benchmark suite designed to evaluate the performance of various deep model fusion techniques. It aims to provide a comprehensive comparison of different methods on a variety of datasets and tasks.

  Projects based on FusionBench and news from the community (descending order of date):

  <details>
    <summary>Hongling Zheng, Li Shen, Anke Tang, Yong Luo et al. Learn From Model Beyond Fine-Tuning: A Survey. has been accepted for publication in Nature Machine Intelligence. Nov, 2024. https://arxiv.org/abs/2310.08184</summary>

    > Foundation models (FM) have demonstrated remarkable performance across a wide range of tasks (especially in the fields
    of natural language processing and computer vision), primarily attributed to their ability to comprehend instructions and access
    extensive, high-quality data. This not only showcases their current effectiveness but also sets a promising trajectory towards the
    development of artificial general intelligence. Unfortunately, due to multiple constraints, the raw data of the model used for large model
    training are often inaccessible, so the use of end-to-end models for downstream tasks has become a new research trend, which we call
    Learn From Model (LFM) in this article. LFM focuses on the research, modification, and design of FM based on the model interface,
    so as to better understand the model structure and weights (in a black box environment), and to generalize the model to downstream
    tasks. The study of LFM techniques can be broadly categorized into five major areas: model tuning, model distillation, model reuse,
    meta learning and model editing. Each category encompasses a repertoire of methods and strategies that aim to enhance the
    capabilities and performance of FM. This paper gives a comprehensive review of the current methods based on FM from the
    perspective of LFM, in order to help readers better understand the current research status and ideas. To conclude, we summarize the
    survey by highlighting several critical areas for future exploration and addressing open issues that require further attention from the
    research community. The relevant papers we investigated in this article can be accessed at
    https://github.com/ruthless-man/Awesome-Learn-from-Model.
  </details>

  <details>
    <summary>Li Shen, Anke Tang, Enneng Yang et al. Efficient and Effective Weight-Ensembling Mixture of Experts for Multi-Task Model Merging. Oct, 2024. https://github.com/EnnengYang/Efficient-WEMoE</summary>

    <img width="1018" alt="image" src="https://github.com/user-attachments/assets/b7e1279e-87fc-4016-8867-1bff7700e271">

  </details>
  <details>
    <summary>Jinluan Yang et al. Mitigating the Backdoor Effect for Multi-Task Model Merging via Safety-Aware Subspace. Oct, 2024. http://arxiv.org/abs/2410.13910</summary>

    <img width="1018" alt="image" src="https://github.com/user-attachments/assets/679aaa7e-0506-4e09-a12a-345c12cf529f">

  </details>
  <details>
    <summary>Anke Tang et al. SMILE: Zero-Shot Sparse Mixture of Low-Rank Experts Construction From Pre-Trained Foundation Models. Aug, 2024. http://arxiv.org/abs/2408.10174</summary>

    Example notebooks can be found at [examples/smile_upscaling](examples/smile_upscaling).
    ![](examples/smile_upscaling/SMILE.png)

  </details>



  install from PyPI:

  ```bash
  pip install fusion-bench
  ```

  or install the latest version in development from github repository

  ```bash
  git clone https://github.com/tanganke/fusion_bench.git
  cd fusion_bench

  pip install -e . # install the package in editable mode
  ```



  Deep model fusion is a technique that merges, ensemble, or fuse multiple deep neural networks to obtain a unified model.
  It can be used to improve the performance and robustness of model or to combine the strengths of different models, such as fuse multiple task-specific models to create a multi-task model.
  For a more detailed introduction to deep model fusion, you can refer to [W. Li, 2023, 'Deep Model Fusion: A Survey'](https://arxiv.org/abs/2309.15698). We also provide a brief overview of deep model fusion in [our documentation](https://tanganke.github.io/fusion_bench/).
  In this benchmark, we evaluate the performance of different fusion methods on a variety of datasets and tasks.



  The project is structured as follows:

  - `fusion_bench/`: the main package of the benchmark.
    - `method`: contains the implementation of the fusion methods.
      > **naming convention**: `fusion_bench/method/{method_name}/{variant}.py` contains the implementation of the specific method or its variants.
        For example, `fusion_bench/method/regmean/clip_regmean.py` contains the implementation of the RegMean algorithm for CLIP vision models.
    - `modelpool`: contains the implementation of the model pool, responsible for managing the models and dataset to be loaded.
    - `taskpool`: contains the implementation of the task pool, responsible for evaluating the performance of models returned by the algorithm.
  - `config/`: configuration files for the benchmark. We use [Hydra](https://hydra.cc/) to manage the configurations.
    - `method`: configuration files for the fusion methods.
      > **naming convention**: `config/method/{method_name}/{variant}.yaml` contains the configuration for the specific method or its variants.
    - `modelpool`: configuration files for the model pool.
    - `taskpool`: configuration files for the task pool.
    - `model`: configuration files for the models.
    - `dataset`: configuration files for the datasets.
  - `docs/`: documentation for the benchmark. We use [mkdocs](https://www.mkdocs.org/) to generate the documentation. Start the documentation server locally with `mkdocs serve`. The required packages can be installed with `pip install -r mkdocs-requirements.txt`.
  - `examples/`: example scripts for running some of the experiments.
    > **naming convention**: `examples/{method_name}/` contains the files such as bash scripts and jupyter notebooks for the specific method.
  - `tests/`: unit tests for the benchmark.



  The `fusion_bench` command-line interface is a powerful tool for researchers and practitioners in the field of model fusion. It provides a streamlined way to experiment with various fusion algorithms, model combinations, and evaluation tasks.
  By leveraging Hydra's configuration management, fusion_bench offers flexibility in setting up experiments and reproducibility in results.
  The CLI's design allows for easy extension to new fusion methods, model types, and tasks, making it a versatile platform for advancing research in model fusion techniques.

  Read the [CLI documentation](https://tanganke.github.io/fusion_bench/cli/fusion_bench/) for more information.



  First, create a new Python file for the algorithm in the `fusion_bench/method` directory.
  Following the naming convention, the file should be named `{method_name_or_class}/{variant}.py`.

  ```python
  from fusion_bench import BaseModelFusionAlgorithm, BaseModelPool

  class DerivedModelFusionAlgorithm(BaseModelFusionAlgorithm):
      """
      An example of a derived model fusion algorithm.
      """

      
      
      
      _config_mapping = BaseModelFusionAlgorithm._config_mapping | {
          "hyperparam_attr_1": "hyperparam_1",
          "hyperparam_attr_2": "hyperparam_2",
      }

      def __init__(self, hyperparam_1, hyperparam_2, **kwargs):
          self.hyperparam_attr_1 = hyperparam_1
          self.hyperparam_attr_2 = hyperparam_2
          super().__init__(**kwargs)

      def run(self, modelpool: BaseModelPool):
          
          
          raise NotImplementedError(
              "DerivedModelFusionAlgorithm.run() is not implemented."
          )
  ```

  A corresponding configuration file should be created to specify the class and hyperparameters of the algorithm.
  Here we assume the configuration file is placed at `config/method/your_algorithm_config.yaml`.

  > [!NOTE]
  > In fact, you can place your implementation anywhere you like, as long as the `_target_` in the configuration file points to the correct class.

  ```yaml
  _target_: path_to_the_module.DerivedModelFusionAlgorithm

  hyperparam_1: some_value
  hyperparam_2: another_value
  ```

  Use the algorithm in the FusionBench:

  ```bash
  fusion_bench \
    method=your_algorithm_config \
    method.hyperparam_1=you_can_override_this \
    method.hyperparam_2=and_this \
    ... # other configurations
  ```



  We provide a project template for quickly starting a new fusion algorithm implementation here: [FusionBench Project Template](https://github.com/fusion-bench/fusion-bench-project-template).

  <div align='center'>

  Click on [<kbd>Use this template</kbd>](https://github.com/fusion-bench/fusion-bench-project-template/generate) to initialize new repository.

  </div>



  FusionBench Command Generator is a user-friendly web interface for generating FusionBench commands based on configuration files.
  It provides an interactive way to select and customize FusionBench configurations, making it easier to run experiments with different settings.
  [Read more here](https://tanganke.github.io/fusion_bench/cli/fusion_bench_webui/).

  ![FusionBench Command Generator Web Interface](docs/cli/images/fusion_bench_webui.png)



  If you find this benchmark useful, please consider citing our work:

  ```bibtex
  @misc{tangFusionBenchComprehensiveBenchmark2024,
    title = {{{FusionBench}}: {{A Comprehensive Benchmark}} of {{Deep Model Fusion}}},
    shorttitle = {{{FusionBench}}},
    author = {Tang, Anke and Shen, Li and Luo, Yong and Hu, Han and Du, Bo and Tao, Dacheng},
    year = {2024},
    month = jun,
    number = {arXiv:2406.03280},
    eprint = {2406.03280},
    publisher = {arXiv},
    url = {http://arxiv.org/abs/2406.03280},
    archiveprefix = {arxiv},
    langid = {english},
    keywords = {Computer Science - Artificial Intelligence,Computer Science - Computation and Language,Computer Science - Machine Learning}
  }
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Anke Tang  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: eca390165f1bd7877413052fc8d000057743c72035d108ab481ee877eef2aae3
name: python-fusion-engine-client-help
arch: noarch
version: 1.23.5
epoch: 0
release: 1
summary: Development documents and examples for fusion-engine-client
url: https://github.com/PointOneNav/fusion-engine-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fusion-engine-client-1.23.5-1.src.rpm
location_href: Packages/python-fusion-engine-client-help-1.23.5-1.noarch.rpm
checksum_type: sha256
description:
  Point One FusionEngine protocol support for real-time interaction and control, plus post-processing data analysis tools.

  See https://github.com/PointOneNav/fusion-engine-client for full details. See https://pointonenav.com/docs/
  for the latest FusionEngine message specification.


pkgId: 9ed845af755711344c62b6b6be1ff190125b15b4c0f8607eacbb0458ac9755b6
name: python-fusion-platform-python-sdk-help
arch: noarch
version: 1.15.11
epoch: 0
release: 1
summary: Development documents and examples for fusion-platform-python-sdk
url: https://github.com/d-cat-support/fusion-platform-python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fusion-platform-python-sdk-1.15.11-1.src.rpm
location_href: Packages/python-fusion-platform-python-sdk-help-1.15.11-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the Python SDK used to interact with the Fusion Platform<sup>&reg;</sup>. The Fusion Platform<sup>&reg;</sup> provides enhanced remote
  monitoring services. By ingesting remotely sensed Earth Observation (EO) data, and data from other sources, the platform uses and fuses this data to execute
  algorithms which provide actionable knowledge to customers.

  The Python SDK is designed to enable interaction with the Fusion Platform<sup>&reg;</sup> via its API. As such, the SDK therefore allows software to login, upload
  files, create and execute processes, monitor their execution and then download the corresponding results. Additional functionality is available directly via the
  API, and this is defined within the corresponding OpenAPI 3.0 specification, which can be obtained via a support request.

  [&copy; Digital Content Analysis Technology Ltd](https://www.d-cat.co.uk)



  The SDK has been built for Python 3, and is tested against Python 3.8, 3.9, 3.10, 3.11 and 3.12. To install the SDK into a suitable Python environment containing
  `pip`, execute the following:

  ```shell
  pip install fusion-platform-python-sdk
  ```

  This will install the SDK and all its dependencies.

  To update an existing installation to the latest version, execute the following:

  ```shell
  pip install fusion-platform-python-sdk --upgrade
  ```



  The following shows a simple example of how to use the SDK to create a process, execute it and download the resulting data. This example assumes that a suitable
  user account has been created with an organisation which has sufficient credits to run the process, and that the SDK has been installed as above. To use a different
  user account, replace the email address `me@org.com` and password `MyPassword123!`.

  The example uses a pre-defined region of interest for Glasgow, and then obtains spectral indices for the region. A range of spectral indices are built using ESA's
  Sentinel-2 multi-spectral data from the most recent date available for Glasgow.

  ```python
  import os
  import fusion_platform


  user = fusion_platform.login(email='me@org.com', password='MyPassword123!')




  organisation = next(user.organisations)


  glasgow = organisation.create_data(name='Glasgow', file_type=fusion_platform.FILE_TYPE_GEOJSON, files=[fusion_platform.EXAMPLE_GLASGOW_FILE], wait=True)


  service, _ = organisation.find_services(keyword='Elevation')


  process = organisation.new_process(name='Example', service=service)


  process.update(input_number=1, data=glasgow)


  process.create()


  print(f"Price: {process.price}")


  process.execute(wait=True)



  execution = next(process.executions)


  for i, component in enumerate(execution.components):
      print(f"Downloading {component.name}")
      component_dir = f"component_{str(i)}"

      for j, output in enumerate(component.outputs):
          dir = os.path.join(component_dir, str(j))
          for file in output.files:
              file.download(path=os.path.join(dir, file.file_name))


  process.delete()
  glasgow.delete()
  ```



  Details of the methods and attributes available from objects used within the SDK can be
  found [https://www.d-cat.co.uk/public/fusion_platform_python_sdk/](https://www.d-cat.co.uk/public/fusion_platform_python_sdk/).

  Full documentation can be found
  in [fusion_platform_sdk.pdf](https://github.com/d-cat-support/fusion-platform-python-sdk/blob/master/fusion_platform/fusion_platform_sdk.pdf).



  Support for the SDK can be obtained by contacting Digital Content Analysis Technology Ltd via [support@d-cat.co.uk](mailto:support@d-cat.co.uk).



  See [LICENSE.txt](LICENSE.txt).


pkgId: 7e3f53e62297d0c36bcd0f9aa08f1d592911aedf10f27071004aebc3cf5b6c52
name: python-future-sales-prediction-2024-help
arch: noarch
version: 3.4.15
epoch: 0
release: 1
summary: Development documents and examples for future-sales-prediction-2024
url: https://pypi.org/project/future-sales-prediction-2024/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-future-sales-prediction-2024-3.4.15-1.src.rpm
location_href: Packages/python-future-sales-prediction-2024-help-3.4.15-1.noarch.rpm
checksum_type: sha256
description:
  Future Sales Prediction 2024 is a Python package designed for building robust time-series sales prediction models. The package integrates preprocessing, feature engineering, hyperparameter optimization, and model training workflows, leveraging DVC for data versioning and Google Cloud Storage for seamless data access.







  * Data Handling: Tools to preprocess raw datasets and optimize memory usage.
  * Feature Engineering: Generate and refine features for predictive modeling.
  * Hyperparameter Tuning: Automate parameter optimization with Hyperopt.
  * Model Training: Time-series cross-validation and training for regression models.
  * Validation: Validate data integrity to ensure quality and consistency.
  * Data Versioning: DVC integration for easy data retrieval from Google Cloud.


  Install the package using pip:

  pip install future_sales_prediction_2024


  * Step 1: Authenticate with Google Cloud
  Before fetching data, authenticate with Google Cloud:

  Option A: Use Google Cloud SDK: gcloud auth application-default login

  Option B: Use a Service Account key file: export GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.json

  * Step 2: Pull the Data
  Step 2: Pull the Data

  Option A - locally:
  - Use the pull_data.py script to clone the repository, fetch DVC-tracked data, and save it to the current directory:

  * pull_data --repo https://github.com/YPolina/Trainee.git --branch DS-4.1

  Option B - using online-service(Google Colab, Kaggle and etc.)
  * !pull_data --repo https://github.com/YPolina/Trainee.git --branch DS-4.1

  This will:

  Clone the repository.
  Pull datasets tracked via DVC from Google Cloud Storage.
  Save datasets in a folder called data_pulled in the current working directory.

  * Step 3: Explore the Codebase and Build Models
  After fetching the data, you can explore and use the following modules:

  ____________________________________________


  File: future_sales_prediction_2024/data_handling.py

  prepare_full_data(items, categories, train, shops, test) -> pd.DataFrame
  Merges raw datasets into a single comprehensive dataset (full_data.csv), available after dvc pull.

  reduce_mem_usage(df) -> pd.DataFrame
  Optimizes memory usage by converting data types where applicable.


  File: future_sales_prediction_2024/feature_extraction.py

  Class: FeatureExtractor
  Extracts features for predictive modeling.

  Initialization Parameters:
  full_data: Full dataset containing all columns.
  train: Training data for aggregating revenue-based features.
  Output:
  Returns a processed dataset (full_featured_data.csv), stored in preprocessed_data after dvc pull.

  Class: FeatureImportanceLayer
  Analyzes feature importance using baseline and tuned models.

  Initialization Parameters:

  X: Feature matrix.
  y: Target vector.
  output_dir: Directory for saving feature importance plots.
  Key Methods:

  fit_baseline_model(): Trains a baseline model for feature importance based on RandomForestRegressor.
  plot_baseline_importance(): Visualizes baseline model feature importance.
  fit_final_model(): Trains a final model with optimized hyperparameters - model-agnostic.
  Parameters:
  - Model (XGBRegressor by default)
  - params: Model hyperparameters (Optional)
  - use_shap(bool): Use SHAP values if the model doesn't provide native feature importance
  plot_final_model_importance(): Visualizes feature importance for the final model.

  Output of plot_baseline_importance and plot_final_model_importance: feature_importance_results/baseline_importance.png and feature_importance_results/final_model_importance.png


  File: future_sales_prediction_2024/hyperparameters.py

  hyperparameter_tuning(X, y, model_class, param_space, eval_fn, max_evals=50) -> dict
  Performs hyperparameter optimization using Hyperopt for models like XGBRegressor or RandomForestRegressor.

  Parameters:

  X: Feature matrix.
  y: Target vector.
  model_class: Model class (e.g., XGBRegressor).
  param_space: Search space for hyperparameters.
  eval_fn: Evaluation function for loss metric.
  max_evals: Number of evaluations.
  Returns:
  Best hyperparameters as a dictionary.


  File: future_sales_prediction_2024/model_training.py

  tss_cv(df, n_splits, model, true_pred_plot=True)
  Performs time-series cross-validation and calculates RMSE.
  Returns Mean RMSE for all splits

  df: DataFrame with features and target variable.
  n_splits: Number of cross-validation splits.
  model: Regression model (e.g., XGBRegressor).
  data_split(df) -> Tuple[np.ndarray, ...]
  Splits the data into training, validation, and test sets.

  train_predict(X, y, X_test, model_, model_params=None) -> np.ndarray
  Trains the model with provided features and predicts outcomes.


  File: future_sales_prediction_2024/validation.py

  Class: Validator
  Ensures data quality by checking types, ranges, duplicates, and missing values.

  Initialization Parameters:

  column_types: Expected column data types (e.g., {'shop_id': 'int64'}).
  value_ranges: Numeric range for each column (e.g., {'month': (1, 12)}).
  check_duplicates: Whether to check for duplicate rows.
  check_missing: Whether to check for missing values.
  Method: transform(X)
  Validates a DataFrame and returns a confirmation message if successful.


  This package is a modular and flexible solution for streamlining data science workflows. It provides data scientists and ML engineers with reusable tools to focus on solving domain-specific problems.


pkgId: 8ec1eecf7f98bcf131e2283a5fad23d5bba4a779949f052140c521dbb3bcba29
name: python-futureagi-help
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Development documents and examples for futureagi
url: https://pypi.org/project/futureagi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-futureagi-0.3.4-1.src.rpm
location_href: Packages/python-futureagi-help-0.3.4-1.noarch.rpm
checksum_type: sha256
description:
  ![Company Logo](https://github.com/future-agi/client/blob/main/Logo.png)

  Welcome to Future AGI - Empowering GenAI Teams with Advanced Performance Management



  Future AGI provides a cutting-edge platform designed to help GenAI teams maintain peak model accuracy in production environments.
  Our solution is purpose-built, scalable, and delivers results 10x faster than traditional methods.

  **Key Features**

  * **_Simplified GenAI Performance Management_**: Streamline your workflow and focus on developing cutting-edge AI models.
  * **_Instant Evaluation_**: Score outputs without human-in-the-loop or ground truth, increasing QA team efficiency by up to 10x.
  * **_Advanced Error Analytics_**: Gain ready-to-use insights with comprehensive error tagging and segmentation.
  * **_Configurable Metrics_**: Define custom metrics tailored to your specific use case for precise model evaluation.


  **Installation**

  To install the client, you can clone the repository or install the library:

  Install the library in an environment using Python >= 3.6.
  ```
  $ pip3 install futureagi
  ```
  Or clone the repo:

  ```
  $ git clone https://github.com/future-agi/client
  ```

  **Initialisation**

  To initialise the Future AGI Client, you need to provide your fi_api_key and fi_secret_key, which are associated with your Future AGI account.

  Get your service API key When you create an account, we generate a service API key. You will need this API Key and your Space Key for logging authentication.
  Instrument your code Python Client If you are using the Future AGI python client, add a few lines to your code to log your data. Logs are sent to us asynchronously.

  ```
  from fi.client import Client

  fi_api_key = os.environ["FI_API_KEY"]
  fi_secret_key = os.environ["FI_SECRET_KEY"]
  base_url = os.environ["FI_API_URL"]

  client = Client(fi_api_key=fi_api_key, fi_secret_key=fi_secret_key,
          max_workers=8,
          max_queue_bound=5000,
          timeout=200,
          additional_headers=None,
  )
  ```

  **Initialises the Future AGI Client**
  * _fi_api_key_: provided API key associated with your account.
  * _fi_secret_key_: provided identifier to connect records to spaces.
  * _uri_: URI to send your records to Future AGI client.
  * _max_workers_: maximum number of concurrent requests to Future AGI. Defaults to 8.
  * _max_queue_bound_: maximum number of concurrent future objects generated for publishing to Future AGI. Defaults to 5000.
  * _timeout_: how long to wait for the server to send data before giving up. Defaults to 200.
  * _additional_headers_: Dictionary of additional headers to append to request

  You can also set these keys as environment variables:
  ```
  export FI_API_KEY=your_api_key
  export FI_SECRET_KEY=your_secret_key
  ```
  And then initialise the client without passing the keys directly:

  ```
  from fi.utils.types import ModelTypes, Environments

  client.log(
      model_id="your_model_id",
      model_type=ModelTypes.GENERATIVE_LLM,
      environment=Environments.PRODUCTION,
      model_version="1.0.0",
      prediction_timestamp=1625216400,
      conversation={
          "chat_history": [
              {"role": "user", "content": "How do I implement a neural network in Python?"}
          ]
      },
      tags={"project": "AI project"}
  )
  ```

  **Parameters**
  * 	_model_id_: The ID of the model. Must be a string.
  * 	_model_type_: The type of the model. Must be an instance of ModelTypes.
  * 	_environment_: The environment in which the model is running. Must be an instance of Environments.
  * 	_model_version_: The version of the model. Must be a string.
  * 	_prediction_timestamp_: (Optional) The timestamp of the prediction. Must be an integer.
  * 	_conversation_:  The conversation data. Must be a dictionary containing either chat_history or chat_graph.
  * 	_tags_: (Optional) Additional tags for the event. Must be a dictionary.

  **_[For full details, see our docs.](https://docs.futureagi.com/)_**


  **Conversation Format**

  **Chat History**
  The chat_history must be a list of dictionaries with the following keys:
  * 	_role_: The role of the participant (e.g., “user”, “assistant”). Must be a string.
  * 	_content_: The content of the message. Must be a string.
  * 	_context_: (Optional) The context of the message. Must be a list of pairs of strings in the format [["", ""]...].

  **Chat History with conversation ID**
  The chat_history must be a list of dictionaries with the following keys:
  * 	_conversation_id_: The ID of the conversation. Must be a string.
  * 	_role_: The role of the participant (e.g., “user”, “assistant”). Must be a string.
  * 	_content_: The content of the message. Must be a string.
  * 	_context_: (Optional) The context of the message. Must be a list of pairs of strings in the format [["", ""]...].

  **Chat Graph**
  The chat_graph must be a dictionary with the following keys:
  * 	_conversation_id_: The ID of the conversation. Must be a string.
  * 	_nodes_: A list of nodes, each containing:
  * 	_message_: A dictionary with the message details.
  * 	_node_id_: The ID of the node. Must be a string.
  * 	_parent_id_: The ID of the parent node. Must be a string.
  * 	_timestamp_: The timestamp of the node. Must be an integer.


  1. **Logging data individually:** For example, "chat_history" may include a list of dictionaries where each dictionary represents a message with attributes like "role" (str) and "content" (str) .

  ```
  {
          "chat_history": [
              {
                  "role": "user",
                  "content": "Who won the world series in 2020?"
              },
              {
                  "role": "assistant",
                  "content": "The Los Angeles Dodgers won the World Series in 2020."
              }
          ]
  }
  ```

  1. **Logging data all at once:** This involves logging structured conversations in a unified format:
  ```
  [{
      "conversation_id": "",
      "title": "",
      "root_node": "",
      "metadata": {},
      "nodes": [{
          "parent_node": "",
          "child_node": "",
          "message": {
              "id": "",
              "author": {
                          "role": "assistant",
                          "metadata": {}
                      },
              "content": {
                          "content_type": "text",
                          "parts": [
                              "The user is interested to do this task..."
                          ]
                      }
              "context": ""
          }
      }]
  }]
  ```
  **Error Handling**
  The client raises specific exceptions for different types of errors:
  * 	_AuthError_: Raised if the API key or secret key is missing.
  * 	_InvalidAdditionalHeaders_: Raised if there are conflicting additional headers.
  * 	_InvalidValueType_: Raised if a parameter has an invalid type.
  * 	_InvalidSupportedType_: Raised if a model type is not supported.
  * 	_MissingRequiredKey_: Raised if a required key is missing.
  * 	_InvalidVectorLength_: Raised if the vector length is invalid.



  1. Q: How do you give a performance score without human in the loop?

  Our secret Sauce is a Critique AI agent that can deliver powerful evaluation framework without need for human in the loop. What’s more is that it is 100% configurable as per new evolving use cases. Now anything that you can imagine your AI system should deliver - you can configure our platform to manage it.

  2. Q: What all inputs Future AGI platform needs?

  We would need only the input-output database, training dataset if available, and User-analytics. We do not need to understand the model and how it is taking decisions.

  3. Q: I don't want to share data with Future AGI, can I still use it?

  Yes, you can now install our SDK in your private cloud and take advantage of our strong platform to align your AI system to your users.


  4. Q: My use case is unique, would you provide service to customise your platform as per my use case?

  Our platform is 100% customisable and easy to configure for all types of models and modalities by the AI teams. However, our customer-success engineer would be happy to assist you for figuring out solutions to your unique use cases.

  5. Q: My app uses multiple models with multiple modalities, can you work with images and videos also?

  Yes we can.

  6. Q: How much time does it take to integrate the Future AGI platform? How much bandwidth would be required?

  It takes just 2 minutes to integrate a few lines of code and your data starts showing on our platform. Try it today.




  **Website**: https://www.futureagi.com/

  **Documentation**: https://docs.futureagi.com/

  **PyPI** : https://pypi.org/project/futureagi/


pkgId: dfbf462ff0b5b9001d802d9bddea208648a602967ffee40110d08e9044a18c34
name: python-fuzz-introspector-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for fuzz-introspector
url: https://github.com/ossf/fuzz-introspector
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fuzz-introspector-0.1.3-1.src.rpm
location_href: Packages/python-fuzz-introspector-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  Library for analysing fuzzer-relevant components of source code.

  Example:

  ```python
  from fuzz_introspector.frontends import core

  SAMPLE="""void parse(const char *data, size_t size) {
    return;
  }

  int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    parse((const char*)data, size)
  }
  """

  source = core.analyse_source_file(SAMPLE, 'c')
  func = source.get_function_node('LLVMFuzzerTestOneInput')
  if func:
      print(func.callsites())
  ```

  Running the above:

  ```sh
  $ python3 example.py
  [('parse', (122, 127))]
  ```


pkgId: 8b2042c8e7be7118e14ce52e79bf62f1d9693caa69386c3ec0ba3a3be9bf8eef
name: python-fwdi-help
arch: noarch
version: 0.0.61
epoch: 0
release: 1
summary: Development documents and examples for fwdi
url: https://github.com/Alitrix/fwdi-dev
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fwdi-0.0.61-1.src.rpm
location_href: Packages/python-fwdi-help-0.0.61-1.noarch.rpm
checksum_type: sha256
description:
  A lightweight library that makes it easy to create and use controller-based web services using dependency injection.
  Code of Conduct. Flat Web Dependency Injection Service is a lightweight open source library that allows you to use
  web roots with necessary dependency injection by automatically populating class constructors.

  This library will be regularly modified and built further, this is the Alpha version.


pkgId: 042c664ab6162c16d877fc94140654cb7a3d8b64f315412ddc2be84b50202e1a
name: python-fxdc-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for fxdc
url: https://github.com/KazimFedxD/FedxD-Data-Container
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fxdc-1.0.1-1.src.rpm
location_href: Packages/python-fxdc-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ```py
  name|str = "John"
  age|int = 23
  address|dict:
  	street|str = "123 Main St"
  	city|str = "New York"
  phone|list:
  	a|str = "555-1234"
  	b|str = "555-4567"
  ```




  ```json
  {
      "name": "John",
      "age": 23,
      "address": {
          "street": "123 Main St",
          "city": "New York"
      },
      "phone": [
          "555-1234",
          "555-4567"
      ]
  }
  ```



  1. install the  python pacakge
  	`pip install fxdc`
  2. import fxdc `import fxdc`
  3. Enjoy





  ```py
  name="John"
  age=12
  salary=1000.00
  ```


  ```py
  name|str="John"
  age|int=12
  is_male|bool=1
  salary|float=1000.00
  ```




  ```py
  mydict:
  	name|str="John"
  	age|int=12
  ```





  ```py
  mylist|list:
  	a=100
  	b="john"
  	c=1203.323
  	d|bool="False"
  ```

  ```py
  [100, "john", 1203.323, False]
  ```



  ```py
  members|list:
  	a|dict:
  		name="John"
  		age=10
  	b:
  		name="Micheal"
  		age = 120
  ```

  ```py
  [
  	{
  		"name": "John",
  		"age": 10
  	},
  	{
  		"name": "Micheal",
  		"age": 120
  	}
  ]
  ```




  ```py
  class MyClass:
  	def __init__(self, name, age):
  		self.name = name
  		self.age = age
  	def __repr__(self):
  		return f"<{self.name}: {self.age}>"
  ```

  ```py
  main|MyClass:
  	name="john"
  	age=23
  ```

  ```py
  from fxdc import Config

  class MyClass:
  	def __init__(self, name, age):
  		self.name = name
  		self.age = age
  	def __repr__(self):
  		return f"<{self.name}: {self.age}>"

  Config.add_class("MyDopeClass", MyClass)
  ```


  ```py
  main|MyDopeClass:
  	name="john"
  	age=23
  ```



  ```py
  from fxdc import Config

  Config.add_class("MyClass", MyClass) #Name of Class, Class
  ```


  ```py
  class MyClass:
  	def __init__(self, name, age):
  		self.name = name
  		self.age = age
  		self.salary = age * 2
  	def __repr__(self):
  		return f"<{self.name}: {self.age}>"
  	def to_data(self) -> dict:
  		return {
  			"name": self.name,
  			"age": self.age
  		}
  	@staticmethod
  	def from_data(**kwargs) -> "MyClass":
  		return MyClass(kwargs["name"], kwargs["age"])
  ```








  ```py
  import fxdc

  fxdcobject = fxdc.load("main.fxdc") #Name of the File
  ```



  ```py
  import fxdc

  with open("main.fxdc", "w") as f:
  	fxdcobject = fxdc.load(f)
  ```



  ```py
  fxdcstring = """
  name|str = "John"
  age|int = 23
  address|dict:
  	street|str = "123 Main St"
  	city|str = "New York"
  phone|list:
  	a|str = "555-1234"
  	b|str = "555-4567"
  """

  from fxdc import loads

  fxdcobject = loads(fxdcstring)
  ```








  ```py
  class MyClass:
  	def __init__(self, name:str, age:int):
  		self.name = name
  		self.age = age

  	def __repr__(self):
  		return f"{self.name}: {self.age}"

  from fxdc import dumps

  obj = MyClass("John", 23)

  fxdcstring = dumps(obj)
  print(fxdcstring)
  ```
  ```
  main|MyClass:
          name|str="John"
          age|int=20
  ```





  ```py
  from fxdc import Config

  Config.set_recursion_limit(10000) #Default is 5000 U Can Increase That
  ```


pkgId: b5d790776704eaea7a74964fe7be87afd312d351d2cf14b4c181081d6b9cc2f0
name: python-fxgui-help
arch: noarch
version: 6.3.5
epoch: 0
release: 1
summary: Development documents and examples for fxgui
url: https://github.com/healkeiser/fxgui
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fxgui-6.3.5-1.src.rpm
location_href: Packages/python-fxgui-help-6.3.5-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

    ![Logo](https://raw.githubusercontent.com/healkeiser/fxgui/main/fxgui/images/fxgui_logo_background_dark.svg#gh-light-mode-only)
    ![Logo](https://raw.githubusercontent.com/healkeiser/fxgui/main/fxgui/images/fxgui_logo_background_light.svg#gh-dark-mode-only)

    <h3 align="center">fxgui</h3>

    <p align="center">
      Custom Python classes and utilities tailored for Qt built UI, in VFX-oriented DCC applications.
      <br/><br/>
      <a href="https://healkeiser.github.io/fxgui"><strong>Documentation</strong></a>
    </p>

    

    <p align="center">
      <!-- Maintenance status -->
      <img src="https://img.shields.io/badge/maintenance-actively--developed-brightgreen.svg?&label=Maintenance"> &nbsp;&nbsp;
      <!-- <img src="https://img.shields.io/badge/maintenance-deprecated-red.svg?&label=Maintenance">&nbsp;&nbsp; -->
      <!-- License -->
      <img src="https://img.shields.io/github/license/healkeiser/fxgui?&label=License"/> &nbsp;&nbsp;
      <!-- GitHub build workflow -->
      <img src="https://img.shields.io/github/actions/workflow/status/healkeiser/fxgui/python-publish.yml?&label=Build&logo=pypi&logoColor=white" alt="Build"> &nbsp;&nbsp;
      <!-- PyPI version-->
      <a href="https://pypi.org/project/fxgui">
        <img src="https://img.shields.io/pypi/v/fxgui?&logo=pypi&logoColor=white&label=Version" alt="PyPI version"/></a> &nbsp;&nbsp;
      <!-- PyPI downloads -->
      <a href="https://pepy.tech/project/fxgui">
        <img src="https://static.pepy.tech/badge/fxgui" alt="PyPI Downloads"></a> &nbsp;&nbsp;
      <!-- Last Commit -->
      <img src="https://img.shields.io/github/last-commit/healkeiser/fxgui?logo=github&label=Last%20Commit" alt="Last Commit"> &nbsp;&nbsp;
      <!-- Commit Activity -->
      <a href="https://github.com/healkeiser/fxgui/pulse" alt="Activity">
        <img src="https://img.shields.io/github/commit-activity/m/healkeiser/fxgui?&logo=github&label=Commit%20Activity"></a> &nbsp;&nbsp;
      <!-- GitHub stars -->
      <img src="https://img.shields.io/github/stars/healkeiser/fxgui" alt="GitHub Stars"/> &nbsp;&nbsp;
    </p>

  </div>



  <!-- TABLE OF CONTENTS -->


  - [Table of Contents](#table-of-contents)
  - [About](#about)
  - [Installation](#installation)
  - [Example](#example)
  - [Documentation](#documentation)
  - [Screenshots](#screenshots)
  - [Contact](#contact)



  <!-- ABOUT -->


  Custom Python classes and utilities tailored for Qt built UI, in VFX-oriented DCC applications.



  <!-- INSTALLATION -->


  The package is available on [PyPI](https://pypi.org/project/fxgui) and can be installed via `pip`:


  ``` shell
  python -m pip install fxgui
  ```

  The repository contains submodules, so make sure to clone the repository with the `--recurse-submodules` flag:

  ``` shell
  git clone --recurse-submodules https://github.com/healkeiser/fxgui
  ```

  Or, if you already cloned the repository, you can initialize the submodules with:

  ``` shell
  git submodule update --init --recursive
  ```

  > [!IMPORTANT]
  > In order to have access to the module inside your application, make sure to add `fxgui` to the `$PYTHONPATH` of the DCCs. For Houdini, you can find the [`houdini_package.json` example file](./houdini_package.json).



  <!-- EXAMPLE -->


  After installing fxgui, you can run the demo:

  ``` shell
  python examples.py
  ```

  Or:

  ``` python
  from fxgui import examples

  examples.main()
  ```



  <!-- DOCUMENTATION -->


  Please read the full documentation [here](https://healkeiser.github.io/fxgui/).



  <!-- SCREENSHOTS -->

  <p align="center">
    <img width="500" src="docs/images/python_yFzxAPqS13.png">
    <img width="500" src="docs/images/python_x9pbgeXwaT.png">
    <img width="500" src="docs/images/python_8O8aQuwsy8.png">
    <img width="500" src="docs/images/python_EM6S9rdJYw.png">
  </p>



  <!-- CONTACT -->


  Project Link: [fxgui](https://github.com/healkeiser/fxgui)

  <p align='center'>
    <!-- GitHub profile -->
    <a href="https://github.com/healkeiser">
      <img src="https://img.shields.io/badge/healkeiser-181717?logo=github&style=social" alt="GitHub"/></a>&nbsp;&nbsp;
    <!-- LinkedIn -->
    <a href="https://www.linkedin.com/in/valentin-beaumont">
      <img src="https://img.shields.io/badge/Valentin%20Beaumont-0A66C2?logo=linkedin&style=social" alt="LinkedIn"/></a>&nbsp;&nbsp;
    <!-- Behance -->
    <a href="https://www.behance.net/el1ven">
      <img src="https://img.shields.io/badge/el1ven-1769FF?logo=behance&style=social" alt="Behance"/></a>&nbsp;&nbsp;
    <!-- X -->
    <a href="https://twitter.com/valentinbeaumon">
      <img src="https://img.shields.io/badge/@valentinbeaumon-1DA1F2?logo=x&style=social" alt="Twitter"/></a>&nbsp;&nbsp;
    <!-- Instagram -->
    <a href="https://www.instagram.com/val.beaumontart">
      <img src="https://img.shields.io/badge/@val.beaumontart-E4405F?logo=instagram&style=social" alt="Instagram"/></a>&nbsp;&nbsp;
    <!-- Gumroad -->
    <a href="https://healkeiser.gumroad.com/subscribe">
      <img src="https://img.shields.io/badge/healkeiser-36a9ae?logo=gumroad&style=social" alt="Gumroad"/></a>&nbsp;&nbsp;
    <!-- Gmail -->
    <a href="mailto:valentin.onze@gmail.com">
      <img src="https://img.shields.io/badge/valentin.onze@gmail.com-D14836?logo=gmail&style=social" alt="Email"/></a>&nbsp;&nbsp;
    <!-- Buy me a coffee -->
    <a href="https://www.buymeacoffee.com/healkeiser">
      <img src="https://img.shields.io/badge/Buy Me A Coffee-FFDD00?&logo=buy-me-a-coffee&logoColor=black" alt="Buy Me A Coffee"/></a>&nbsp;&nbsp;
  </p>


pkgId: 4ae2e50b5762a1525d8d70463040b095780189ab815ce40dc3d1657b459b7c92
name: python-fy_library-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for fy_library
url: https://pypi.org/project/fy_library/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fy_library-0.4.1-1.src.rpm
location_href: Packages/python-fy_library-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  _Fy Library_ is the core functional part of the `fy` tool. It contains code for discovering and parsing `fy` code, then generating resulting Python code.



  We develop the `fy` tool using the very same `fy` tool. But we cannot use the same copy that we use for development to transform edited `fy` files because files break during development.

  For that purpose of avoiding breaking the very same tool that we use for development, we clone another repo that we use as a source code for running the `fy` cli tool.



  Clone the same `fy` repo once more in the `local-fy-cli` folder adjacent to this project folder. FYI, the second parameter in `git clone` is the directory to clone the repo in like:

  ```shell
  git clone git@github.com:execution-flows/fy.git local-fy-cli
  ```

  After cloning the repo your directory structure should be like:
  ```
  ├── fy
  │   ├── cli
  │   ├── documentation_site
  │   ├── library
  │   ├── local.fy.sh
  ├── local-fy-cli
  │   ├── cli
  │   ├── documentation_site
  │   ├── library
  │   ├── local.fy.sh
  ```



  ```shell
  cd local-fy-cli/cli
  poetry env use 3.10
  poetry install
  ```



  In the project root folder

  ```shell
  ./local.fy.sh
  ```

  **NOTE:** `local.fy.sh` is configured with `/library/src` as a project root folder, so only files in that folder can be processed with it.



  1. PyCharm -> Settings -> Tools -> External Tools
  2. '+' (or Add) to create a new tool
  3. Fill in:

     - Name: `local fy`
     - Program: \<path to local.fy.sh>
     - Arguments: `$FileDir$`
     - Working directory: \<path to /library/src>

  Now you can run the tool by selecting `Tools -> External Tools -> local fy`, or option-click on a file or folder and choose `External Tools -> local fy`.

  To speed things up you can assign a keyboard shortcut to it in `PyCharm -> Settings -> Keymap -> External Tools -> External Tools -> local fy`. Then click on pencil at the top, and select `Add Keyboard Shortcut`.



  Regularly, as often as you do with the primary development `fy` repo, run `git pull origin main` in the `local-fy-cli` repo.



  The main principle of `fy` tool development is Test-Driven-Development. The level of tests we use for development is the integration level.

  The integration test in this project means writing the `fy` code, and comparing the generated Python code with the expected Python code.

  To run the tests from `poetry shell` use the following command:

  ```shell
  poetry run python -m unittest
  ```



  Use the poetry shell from the root project.

  ```shell
  poetry env use 3.10
  poetry install
  ```

  We use `pre-commit` to run a bunch of checks before committing to git, if you want to run these checks at any time, on all files you can use

  ```shell
  poetry run pre-commit run -a
  ```


pkgId: e1e896af5315b17fc1fd4b90cb74bddd3cfa24ae096b464f82e85a2ecd9453cd
name: python-fyle-accounting-mappings-help
arch: noarch
version: 1.35.0
epoch: 0
release: 1
summary: Development documents and examples for fyle-accounting-mappings
url: https://github.com/fylein/fyle-accounting-mappings
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-fyle-accounting-mappings-1.35.0-1.src.rpm
location_href: Packages/python-fyle-accounting-mappings-help-1.35.0-1.noarch.rpm
checksum_type: sha256
description:
  Backend infra to support all kinds of mappings in Fyle Accounting Integrations

      $ pip install fyle-accounting-mappings

  In Django `settings.py` -

      INSTALLED_APPS = [
          'django.contrib.admin',
          'django.contrib.auth',
          'django.contrib.contenttypes',
          'django.contrib.sessions',
          'django.contrib.messages',
          'django.contrib.staticfiles',

          
          'rest_framework',
          'corsheaders',
          'fyle_rest_auth', # already existing reusable django app for authentication
          'fyle_accounting_mappings', # new mapping infra app

          
          'apps.users',
          'apps.workspaces',
          'apps.mappings',
          'apps.fyle',
          'apps.quickbooks_online',
          'apps.tasks'
      ]

  Run migrations -

      $ python manage.py migrate

  To use -

      from fyle_accounting_mappings.models import MappingSetting, Mapping, ExpenseTag, DestinationTag


pkgId: d46ad3f395ff390a81b35aa1297c1da6a5fc54758926ad9d1859dbc3a2649c16
name: python-g4f-help
arch: noarch
version: 0.3.9.3
epoch: 0
release: 1
summary: Development documents and examples for g4f
url: https://github.com/xtekky/gpt4free
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-g4f-0.3.9.3-1.src.rpm
location_href: Packages/python-g4f-help-0.3.9.3-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center"><strong>Written by <a href="https://github.com/xtekky">@xtekky</a></strong></p>
  <div id="top"></div>
  > [!IMPORTANT]
  > By using this repository or any code related to it, you agree to the [legal notice](LEGAL_NOTICE.md). The author is **not responsible for the usage of this repository nor endorses it**, nor is the author responsible for any copies, forks, re-uploads made by other users, or anything else related to GPT4Free. This is the author's only account and repository. To prevent impersonation or irresponsible actions, please comply with the GNU GPL license this Repository uses.
  > [!WARNING]
  > _"gpt4free"_ serves as a **PoC** (proof of concept), demonstrating the development of an API package with multi-provider requests, with features like timeouts, load balance and flow control.
  >
  > <sup><strong>Latest version:</strong></sup> [![PyPI version](https://img.shields.io/pypi/v/g4f?color=blue)](https://pypi.org/project/g4f) [![Docker version](https://img.shields.io/docker/v/hlohaus789/g4f?label=docker&color=blue)](https://hub.docker.com/r/hlohaus789/g4f)
  > <sup><strong>Stats:</strong></sup> [![Downloads](https://static.pepy.tech/badge/g4f)](https://pepy.tech/project/g4f) [![Downloads](https://static.pepy.tech/badge/g4f/month)](https://pepy.tech/project/g4f)
  ```sh
  pip install -U g4f[all]
  ```
  ```sh
  docker pull hlohaus789/g4f
  ```

     - **For comprehensive details on new features and updates, please refer to our** [Releases](https://github.com/xtekky/gpt4free/releases) **page**
     - **Installation Guide for Windows (.exe):** 💻 [Installation Guide for Windows (.exe)](#installation-guide-for-windows-exe)
     - **Join our Telegram Channel:** 📨 [telegram.me/g4f_channel](https://telegram.me/g4f_channel)
     - **Join our Discord Group:** 💬🆕️ [discord.gg/qXA4Wf4Fsm](https://discord.gg/qXA4Wf4Fsm)

  Is your site on this repository and you want to take it down? Send an email to takedown@g4f.ai with proof it is yours and it will be removed as fast as possible. To prevent reproduction please secure your API. 😉

  **Take a look at our GUI on the mobile device. We connect to ChatGPT and generate an image.**
  [![Preview image](https://github.com/user-attachments/assets/9da24a87-a591-4da4-a80f-8fc7c222c92f)](https://github.com/user-attachments/assets/56c02389-61b1-4849-be7d-50b173b84ce6)

     - [🆕 What's New](#-whats-new)
     - [📚 Table of Contents](#-table-of-contents)
     - [🛠️ Getting Started](#-getting-started)
        - [Docker Container Guide](#docker-container-guide)
        - [Installation Guide for Windows (.exe)](#installation-guide-for-windows-exe)
     - [Use python](#use-python)
        - [Prerequisites](#prerequisites)
        - [Install using PyPI package](#install-using-pypi-package)
        - [Install from source](#install-from-source)
     - [Install using Docker](#install-using-docker)
     - [💡 Usage](#-usage)
        - [Text Generation](#text-generation)
        - [Image Generation](#image-generation)
        - [Web UI](#web-ui)
        - [Interference API](#interference-api)
        - [Local Inference](https://github.com/xtekky/gpt4free/blob/main/docs/local.md)
        - [Configuration](#configuration)
        -  [Full Documentation for Python API](#full-documentation-for-python-api)
           - [Requests API from G4F](https://github.com/xtekky/gpt4free/blob/main/docs/requests.md)
           - [Client API from G4F](https://github.com/xtekky/gpt4free/blob/main/docs/client.md)
           - [AsyncClient API from G4F](https://github.com/xtekky/gpt4free/blob/main/docs/async_client.md)
     - [🚀 Providers and Models](https://github.com/xtekky/gpt4free/blob/main/docs/providers-and-models.md)
     - [🔗 Powered by gpt4free](#-powered-by-gpt4free)
     - [🤝 Contribute](#-contribute)
        - [How do i create a new Provider?](#guide-how-do-i-create-a-new-provider)
        - [How can AI help me with writing code?](#guide-how-can-ai-help-me-with-writing-code)
     - [🙌 Contributors](#-contributors)
     - [©️ Copyright](#-copyright)
     - [⭐ Star History](#-star-history)
     - [📄 License](#-license)



  1. **Install Docker:** Begin by [downloading and installing Docker](https://docs.docker.com/get-docker/).
  2. **Set Up the Container:**
     Use the following commands to pull the latest image and start the container:
  ```sh
  docker pull hlohaus789/g4f
  docker run \
    -p 8080:8080 -p 1337:1337 -p 7900:7900 \
    --shm-size="2g" \
    -v ${PWD}/har_and_cookies:/app/har_and_cookies \
    -v ${PWD}/generated_images:/app/generated_images \
    hlohaus789/g4f:latest
  ```
  To run the slim docker image. Use this command:
  ```bash
  docker run \
    -p 1337:1337 \
    -v ${PWD}/har_and_cookies:/app/har_and_cookies \
    -v ${PWD}/generated_images:/app/generated_images \
    hlohaus789/g4f:latest-slim \
    rm -r -f /app/g4f/ \
    && pip install -U g4f[slim] \
    && python -m g4f --debug
  ```
  It also updates the `g4f` package at startup and installs any new required dependencies.
  3. **Access the Client:**
     - To use the included client, navigate to: [http://localhost:8080/chat/](http://localhost:8080/chat/) or [http://localhost:1337/chat/](http://localhost:1337/chat/)
     - Or set the API base for your client to: [http://localhost:1337/v1](http://localhost:1337/v1)
  4. **(Optional) Provider Login:**
     If required, you can access the container's desktop here: http://localhost:7900/?autoconnect=1&resize=scale&password=secret for provider login purposes.

  To ensure the seamless operation of our application, please follow the instructions below. These steps are designed to guide you through the installation process on Windows operating systems.

  1. **Download the Application**: Visit our [releases page](https://github.com/xtekky/gpt4free/releases/tag/0.3.4.2) and download the most recent version of the application, named `g4f.exe.zip`.
  2. **File Placement**: After downloading, locate the `.zip` file in your Downloads folder. Unpack it to a directory of your choice on your system, then execute the `g4f.exe` file to run the app.
  3. **Open GUI**: The app starts a web server with the GUI. Open your favorite browser and navigate to `http://localhost:8080/chat/` to access the application interface.
  4. **Firewall Configuration (Hotfix)**: Upon installation, it may be necessary to adjust your Windows Firewall settings to allow the application to operate correctly. To do this, access your Windows Firewall settings and allow the application.


pkgId: 45d622f02eeb6da18410beb09b6c6e68ef6793eb0a6d2f4d5527e20a96205b6d
name: python-gOdoo-cli-help
arch: noarch
version: 0.12.8
epoch: 0
release: 1
summary: Development documents and examples for gOdoo-cli
url: https://github.com/OpenJKSoftware/gOdoo
rpm_license: LGPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gOdoo-cli-0.12.8-1.src.rpm
location_href: Packages/python-gOdoo-cli-help-0.12.8-1.noarch.rpm
checksum_type: sha256
description:
  ![OdooLogo](https://raw.githubusercontent.com/OpenJKSoftware/gOdoo/main/assets/odoo_logo.png)
  ![ComposeLogo](https://raw.githubusercontent.com/docker/compose/v2/logo.png)

  [<img src="https://raw.githubusercontent.com/OpenJKSoftware/gOdoo/main/assets/godoo-main-cli.png" width="1000"/>](image.png)

  **gOdoo** is short for **go Odoo**. \
  It is a [Vscode Devcontainer](https://code.visualstudio.com/docs/remote/containers) Environment for [Odoo](https://odoo.com/)
  with Python CLI `godoo` convenience wrapper around `odoo-bin`.

  This repository is the base source for the Python package [godoo-cli](https://pypi.org/project/godoo-cli/) and serves as
  an all batteries included development environment.

  This is the source repository for `gOdoo`. If you want to use `gOdoo` please refer to [./docker/Dockerfile](./docker/Dockerfile) and modify it to install godoo using Pip.

  Made Possible by: [WEMPE Elektronic GmbH](https://wetech.de)



  Python package that provides `godoo` command line interface around `odoo-bin`.

  It's build with [Typer](https://github.com/tiangolo/typer) to provide some convenience Wrappers for Odoo development and
  Deployment.

  Most flags can be configured by Env variables. \
  Use `godoo --help` to find out more. HINT: Install tab-completion with `godoo --install-completion`



  This workspace also contains Docker and Docker-Compose files. \

  They are used to provide either easy Odoo instances where the source is pulled according to
  [ODOO_MANIFEST.yml](odoo_manifest.yml), or as a all batteries included devcontainer for VScode.



  - [Docker Compose](https://github.com/docker/compose)
  - [Traefik](https://doc.traefik.io/traefik/) container running with docker provider and "traefik" named docker network.
    Example: [Traefik Devproxy](https://github.com/joshkreud/traefik_devproxy)
  - SSH Agent running. (check `echo $SSH_AUTH_SOCK`)\
    This gets passed trough in the Buildprocess to clone Thirdparty repos (Optional).



  ```bash
  git clone https://github.com/OpenJKSoftware/gOdoo
  cd godoo
  . scripts/container_requirements.sh # Check Requirements
  docker-compose build
  docker-compose up





  ```





  - All batteries included [Devcontainer](https://code.visualstudio.com/docs/remote/containers) with postgres service
    Container and local DNS resolvig managed by [Traefik](https://doc.traefik.io/traefik/).
  - Easy fully working Odoo instance by `docker-compose up` with https access.
  - `godoo` CLI wrapper around Odoo. (Most flags can be configured by Environment Variables and are already preconfigured
    in the Containers. See [.env.sample](./.env.sample))
  - Cups Container, that provides a CUPS Printserver
  - `odoo-bin` is added to PATH and can thus be invoked from every folder.
  - Odoo will run in Proxy_Mode behind a Traefik reverse proxy for easy access on
    `https://$COMPOSE_PROJECT_NAME.docker.localhost`
  - [Odoo Pylint plugin](https://github.com/OCA/pylint-odoo) preconfigured in vscode
  - Preinstalled vscode Extensions Highlights:
    - [SQL Tools](https://marketplace.visualstudio.com/items?itemName=mtxr.sqltools) with preconfigured connection for
      easy Database access in the Sidebar.
    - [Docker Extension](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-docker) controls
      container host.
    - [Odoo Snippets](https://marketplace.visualstudio.com/items?itemName=mstuttgart.odoo-snippets)
    - [Odoo Developments](https://marketplace.visualstudio.com/items?itemName=scapigliato.vsc-odoo-development) can Grab
      Odoo Model information from a running Server
    - [Todo Tree](https://marketplace.visualstudio.com/items?itemName=Gruntfuggly.todo-tree)



  1. For Docker on windows: Clone the repo into the WSL2 Filesystem for better IO performance
  2. Have [Traefik](https://github.com/traefik/traefik) Running on `docker.localhost`
     [Example](https://github.com/joshkreud/traefik_devproxy) \
     There must be a Docker network called `traefik` that can reach traefik.
  3. Open Devcontianer:
     - If you have the Devcontainer CLI: `devcontainer open .`
     - If not open the workspace in Local Vscode. In the Command pallete search for `Reopen in container`
  4. From **within the container** start Odoo using one of the following commands:
     - You can enable godoo tab-completion by `godoo --install-completion`
     - `make` -> Loads Odoo + Workspace Addons
     - `make bare` -> Loads Odoo with ony `web` installed.
     - `make kill` -> Search for `odoo-bin` processes and kill them
     - `make reset` -> Drops DB, deletes config file and datafolder
     - The full init script is available via "`godoo`". (See --help for Options)
  5. Open Odoo `https://$COMPOSE_PROJECT_NAME.docker.localhost`\
     For example `COMPOSE_PROJECT_NAME=godoo` --> [https://godoo.docker.localhost](https://godoo.docker.localhost)
  6. Login with `admin:admin`
  7. Profit!



  You can access the Odoo source by opening the VsCode workspace [full.code-workspace](full.code-workspace) from within
  the Container. This will open a [Multi-Root Workspace](https://code.visualstudio.com/docs/editor/multi-root-workspaces).
  Really waiting for https://github.com/microsoft/vscode-remote-release/issues/3665 here.



  When you screwed up so bad its time to just start Over godoo has you covered:



  There are 3 Options to reset the Dev Env.

  1. From **Outside** the Container run `make reset` in the project root to delete docker volumes and restart the
     container. (Vscode will prompt to reconnect if still open)
  2. From **Outside** the Container run `make reset-hard` in the project root to force rebuild the main Odoo container and
     then do the same as `make reset`
  3. From **Inside** the Container run `make reset` to drop the DB and delete filestore and config file, which is way
     quicker than the other options.



  1. Close vscode
  2. Remove `app` and `db` container from docker.
  3. Remove volumes: `db, odoo_thirdparty, odoo_web, vscode_extensions`
  4. Restart Devcontainer





  Debugging doesn't reliably work with
  [Odoo Multiprocess](https://www.odoo.com/documentation/14.0/developer/misc/other/cmdline.html#multiprocessing) mode
  enabled. \
  The container ships with a Vscode Debug profile, that sets `--workers 0` to allow for Debugging Breakpoints. See [.vscode/launch.json](./.vscode/launch.json)



  Use `godoo shell` to enter an interactive shell on the Database.





  The `godoo` bootstrap function, will download some modules using git. \
  Which Repos to download is specified in `ODOO_MANIFEST.yml` ([Default](odoo_manifest.yml)) \
  Not all of the cloned addons are automatically installed. \
  Install them via the Apps Page in Odoo using `godoo rpc modules install` or using `odoo-bin`.\
  Modules downloaded on the Odoo Marketplace can be dropped as a `.zip` archive in [./thirdparty](./thirdparty)


pkgId: 675245db8e73e2562d11b143ca9b1923860c1bef7a8e8818a39f21c30e19b9d7
name: python-gable-help
arch: noarch
version: 0.19.0
epoch: 0
release: 1
summary: Development documents and examples for gable
url: https://pypi.org/project/gable/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gable-0.19.0-1.src.rpm
location_href: Packages/python-gable-help-0.19.0-1.noarch.rpm
checksum_type: sha256
description:
  `gable` is Gable on the command line. It publishes contracts, registers data assets and more.

  ```bash
  gable --help
  Usage: gable [OPTIONS] COMMAND [ARGS]...

  Options:
    --endpoint TEXT  Customer API endpoint for Gable, in the format
                     https://api.company.gable.ai/
    --api-key TEXT   API Key for Gable
    --version        Show the version and exit.
    --help           Show this message and exit.

  Commands:
    auth        View configured Gable authentication information
    contract    Validate/publish contracts and check data asset compliance
    data-asset  Commands for data assets
    ping        Pings the Gable API to check for connectivity
  ```



  `gable` is [hosted on PyPi](https://pypi.org/project/gable/), so to install it just run:

  ```bash
  pip install gable
  ```



  Gable's CLI allows you to introspect your database and register tables as data assets within Gable's system. Connecting to these databases require additional packages to communicate with your database(s) of choice.

  For MySQL, install the additional packages by running:

  ```bash
  pip install 'gable[mysql]'
  ```

  For PostgreSQL, install the additional packages by running:

  ```bash
  pip install 'gable[postgres]'
  ```

  To install all additional dependencies at once, you can run:

  ```bash
  pip install 'gable[all]'
  ```



  The Gable CLI supports shell autocomplete for `zsh` and `bash` so you can hit `TAB` to see available commands and options as you write the command.

  To enable it, run the following commands:

  ```bash
  _SHELL=zsh # or bash
  GABLE_CONFIG_DIR=~/.config/gable
  mkdir -p $GABLE_CONFIG_DIR
  _GABLE_COMPLETE=${_SHELL}_source gable > $GABLE_CONFIG_DIR/complete.sh
  ```

  Then add the following to your shell startup scripts (e.g. `.zshrc`, `.bashrc`):

  ```bash
  source ~/.config/gable/complete.sh
  ```



  To establish an authenticated connection with Gable via the CLI, you need:

  - The API endpoint associated with your organization
  - An API key that corresponds to the endpoint

  In order to find your API key and API endpoint, see the documentation in your Gable web app at (`/docs/settings/api_keys`).

  There are two supported methods for providing this config to the CLI:



  You have the option to pass the endpoint and API key information directly as arguments during the CLI invocation. For example:

  ```bash
  gable --endpoint "https://api.yourorganization.gable.ai" --api-key "yourapikey" ping
  ```



  To avoid providing this config every time you execute a command, you can set them as environment variables: `GABLE_API_ENDPOINT` and `GABLE_API_KEY`. To make them persistent in your environment, add this to your shell initialization file (e.g. `.zshrc` or `.bashrc`):

  ```bash
  export GABLE_API_ENDPOINT="https://api.yourorganization.gable.ai"
  export GABLE_API_KEY="yourapikey"
  ```

  Then, you can simply use the CLI as follows:

  ```bash
  gable ping
  ```



  Full releases should be published in an automated way by the github deployment pipelines. In the event we want to quickly deploy a pre-release to a customer:

  1. Update the version in the `pyproject.toml` file by appending a `a0` or `b0` (for alpha or beta), so for example `0.3.0a0`. The number afterwards can be incremented as needed if you need to publish a new version of the pre-release (`a1`, `a2`, etc).
  2. Grab the `API KEY` from the [PyPi Gable Login+API Key login](https://start.1password.com/open/i?a=37NYRM4RXBG3BLSW2NFKNNXTFM&v=t6hkupf3m5e7zdjeyjz3xyzkwu&i=gxevst2nhvjve55wlws5mxnybm&h=manifestdata.1password.com) in the `Engineering` 1password vault.
  3. Run `TWINE_PASSWORD="the value you got from 1password!!!" poetry run poe publish_pypi_pre`
  4. Verify the new version shows up in our [PyPi project history](https://pypi.org/project/gable/#history), and is marked as `PRE-RELEASE`.
  5. Open a PR to commit the new version in the `pyproject.toml`. On merging the automation will fail (gracefully) due to the specified version already existing in pypi


pkgId: f61e331859e08e45d471384da665e3abe7465ad4b94326a63ea5767ba70b2843
name: python-gai-sdk-help
arch: noarch
version: 1.0.85
epoch: 0
release: 1
summary: Development documents and examples for gai-sdk
url: https://pypi.org/project/gai-sdk/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gai-sdk-1.0.85-1.src.rpm
location_href: Packages/python-gai-sdk-help-1.0.85-1.noarch.rpm
checksum_type: sha256
description:
  ```bash
  gai init
  ```

  ```bash
  gai pull exllamav2-mistral7b
  ```

  ```
  gai docker start
  ```
  If it is successfully started, you will see the following:
  ```
  INFO:     Application startup complete.
  INFO:     Uvicorn running on http://0.0.0.0:12031 (Press CTRL+C to quit)
  ```

  ```bash
  gai news
  ```
  ![demo](./doc/img/gai-cli.gif)

  Run [Quick Start Guide](./doc/1-quickstart.ipynb)

rpm_license:
  MIT License  Copyright (c) 2024 kakkoii1337  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: 3e89f49f8f0b08e69b20e0bfee79059a9c3a8d1fb0d9108043d14217bca9bdfb
name: python-gait-tool-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for gait-tool
url: https://github.com/EmpyreanTechnologiesInc/gait.git
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gait-tool-0.1.0-1.src.rpm
location_href: Packages/python-gait-tool-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
    - [Prerequisites](#prerequisites)
    - [Basic Installation and Configuration](#basic-installation-and-configuration)
    - [Installing GitHub CLI](#installing-github-cli)
  - [Usage](#usage)
    - [Basic Git Commands](#basic-git-commands)
    - [AI-Generated Commits](#ai-generated-commits)
    - [AI-Generated Pull Requests](#ai-generated-pull-requests)
    - [Linear Integration and TODO Processing](#linear-integration-and-todo-processing)
  - [Project Structure](#project-structure)





  - Python 3.7 or later ([Download from python.org](https://www.python.org/downloads/))
    ```bash
    python3 --version  # Verify Python installation
    ```
  - Git
    ```bash
    git --version    # Verify Git installation
    ```
  - GitHub CLI (for PR features)
  - OpenAI (requires API key)
  - Linear (requires API key and team ID)


  For macOS:
  1. Clone the repository and install:
     ```bash
     
     git clone https://github.com/EmpyreanTechnologiesInc/gait.git


     
     cd gait
     pip install -e .

     
     gait --version # should display the git version number
     ```

  2. Configure AI Features

     ```bash
     
     
     cp .env.example .env

     
     nano .env   # or vim .env, code .env, etc.

     
     OPENAI_API_KEY=your_api_key_here

     
     OPENAI_MODEL=gpt-4o-mini  # Default model

     
     gait test-api # If successful, you'll see: "API connection successful!"
     ```


  For macOS:
     ```bash
     
     pip install brew

     
     brew install gh
     ```

  After installation, authenticate with GitHub:
  ```bash
  gh auth login # Follow the prompts to complete the authentication process
  ```




  Any git command you know can be used with gait:

  ```bash

  gait status
  gait add .
  gait commit -m "your message"
  gait push


  gait branch -a
  gait checkout -b feature/new-branch
  gait merge main
  ```



  The `gait commit --ai` command analyzes your staged changes and uses AI to generate a descriptive commit message. This feature helps maintain consistent and informative commit messages across your project.

  ```bash

  gait add .


  gait commit --ai





  ```


  The `gait pr create --ai` command analyzes your branch changes and uses AI to generate a descriptive pull request title and body. This feature helps create comprehensive and well-structured pull requests. All standard `gh pr create` options (like `--draft`, `--base`, etc.) are supported.

  ```bash

  gait push


  gait pr create --ai                           # Basic AI-generated PR

  gait pr create --ai --draft                   # Create as draft PR
  gait pr create --ai --base main               # Set target branch





  ```


  When creating a pull request with `gait pr create --ai`, the tool automatically processes TODO comments in your changes:

  1. For new TODOs:
     - Creates corresponding Linear issues
     - Updates the TODO comment with the Linear issue ID
     - Example: `# TODO: Add tests` becomes `# TODO(ENG-123): Add tests`

  2. For removed TODOs:
     - Automatically marks the corresponding Linear issue as "Done"
     - Example: When you remove `# TODO(ENG-123): Add tests`, issue ENG-123 will be marked as completed

  ```bash








  ```

  To use this feature, configure Linear in your `.env` file:
  ```bash
  LINEAR_API_KEY=your_linear_api_key
  LINEAR_TEAM_ID=your_team_id
  LINEAR_PROJECT_ID=your_project_id
  ```
  - Team ID and Project ID can be found on the Linear webpage:
    1. Press `Cmd/Ctrl + K`
    2. Find "Copy model UUID"
    3. select the ID to copy

  - API Key can be found in Settings > API


  ```
  gait/
  ├── src/
  │   └── gait/
  │       ├── __init__.py
  │       ├── main.py
  │       ├── git_wrapper.py
  │       ├── github_wrapper.py
  │       ├── ai_commit.py
  │       ├── ai_pr.py
  │       ├── linear_client.py
  │       └── utils.py
  ├── README.md
  ├── LICENSE
  ├── setup.py
  ├── pyproject.toml
  ├── requirements.txt
  ├── .gitignore
  └── .env.example
  ```

rpm_license:
[cell repeats an earlier one in this file: 10254 characters]


pkgId: 2d903eeff0665b522a854cf34e14ac389af0c1ee354de13129e7319e2ea9c1ac
name: python-gala_fj-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for gala_fj
url: https://pypi.org/project/gala_fj/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gala_fj-0.1.0-1.src.rpm
location_href: Packages/python-gala_fj-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  To make it easy for you to get started with GitLab, here's a list of recommended next steps.

  Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!



  - [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
  - [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:

  ```
  cd existing_repo
  git remote add origin https://code.mahitahi.global.fujitsu.com/NagaSriKrishnaChaitanya.Devaguptapu/gala.git
  git branch -M main
  git push -uf origin main
  ```



  - [ ] [Set up project integrations](https://code.mahitahi.global.fujitsu.com/NagaSriKrishnaChaitanya.Devaguptapu/gala/-/settings/integrations)



  - [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
  - [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
  - [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
  - [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
  - [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)



  Use the built-in continuous integration in GitLab.

  - [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
  - [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
  - [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
  - [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
  - [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)

  ***



  When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.



  Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.


  Choose a self-explaining name for your project.


  Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.


  On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.


  Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.


  Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.


  Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.


  Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.


  If you have ideas for releases in the future, it is a good idea to list them in the README.


  State if you are open to contributions and what your requirements are for accepting them.

  For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.

  You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.


  Show your appreciation to those who have contributed to the project.


  For open source projects, say how it is licensed.


  If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.


pkgId: fc25ce12899cecaa961c8ae1418f4cfa9053d204a8ea5875344f001ade89a5ad
name: python-galaxy-importer-help
arch: noarch
version: 0.4.27
epoch: 0
release: 1
summary: Development documents and examples for galaxy-importer
url: https://github.com/ansible/galaxy-importer
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-galaxy-importer-0.4.27-1.src.rpm
location_href: Packages/python-galaxy-importer-help-0.4.27-1.noarch.rpm
checksum_type: sha256
description:
  ``galaxy-importer`` requires the following other Ansible projects:

  * ``ansible-lint`` up to [24.9.0](https://github.com/ansible/ansible-lint/tree/v24.9.0/docs)
  * ``ansible-core`` up to [2.16](https://docs.ansible.com/ansible-core/2.16/index.html)

  If you are installing from source, see ``setup.cfg`` in the repository for the matching requirements.





  `pip install galaxy-importer`



  Clone repo and go into project directory

  Install into environment the local setup.py including its development dependencies:

  `pip install -e .[dev]`



  Run parsing/validation standalone to view log output and importer result for a build collection artifact file:

  `python -m galaxy_importer.main [collection_artifact_file]`

  Supports legacy roles (note: must be in the parent directory of the legacy role):

  `python -m galaxy_importer.main --legacy-role [legacy_role_directory] --namespace [namespace]`

  Supports converting markdown to html:

  `python -m galaxy_importer.main --markdown [readme_md_directory]`

  View log output in terminal, and view the importer result in the written file `importer_result.json`



  * `metadata` (all data from MANIFEST.json, set by CollectionLoader.\_load_collection_manifest())
  * `docs_blob` (set by CollectionLoader.\_build_docs_blob())
   * `collection_readme`
   * `documentation_files`
   * `contents`
  * `contents`
  * `requires_ansible`




  An optional ini configuration file is supported, the following locations are checked in this order:

  ```
  /etc/galaxy-importer/galaxy-importer.cfg
  <code_source>/galaxy_importer/galaxy-importer.cfg
  ```

  You can override the above paths by setting `GALAXY_IMPORTER_CONFIG` in the environment. For example:

  ```
  $ export GALAXY_IMPORTER_CONFIG=~/galaxy-importer.cfg
  ```

  Configuration options and their defaults are defined in `DEFAULTS` at [galaxy_importer/config.py](galaxy_importer/config.py)

  Example configuration file with subset of config options:

  ```
  [galaxy-importer]
  LOG_LEVEL_MAIN = INFO
  RUN_ANSIBLE_TEST = False
  ANSIBLE_LOCAL_TMP = '~/.ansible/tmp'
  ```

  - `ANSIBLE_LOCAL_TMP` - Set to any desired local Ansible temp directory. Defaults to `~/.ansible/tmp`.

  - `ANSIBLE_TEST_LOCAL_IMAGE` - Set to `True` to run `ansible-test` sandboxed within a container image. Requires installation of either Podman or Docker to run the container. Defaults to `False`.

  - `CHECK_CHANGELOG` - Set to `False` to not check for a `CHANGELOG.rst or` `CHANGELOG.md` file under the collection root or `docs/` dir, or a `changelogs/changelog.(yml/yaml)` file. Defaults to `True`.

  - `CHECK_REQUIRED_TAGS` - Set to `True` to check for a set of tags required for Ansible collection certification. Defaults to `False`.

  - `LOCAL_IMAGE_DOCKER` - Set to `True` to run the `ansible-test` container image via Docker; otherwise, Podman will be used. Defaults to `False`.

  - `LOG_LEVEL_MAIN` - Set to the desired log level. Defaults to `INFO`.

  - `OFFLINE_ANSIBLE_LINT` - Set to `False` if you want `ansible-lint` to check for a new version. Defaults to `True`.

  - `REQUIRE_V1_OR_LATER` - Set to `True` to require a version number `1.0.0` or greater. Defaults to `False`.

  - `RUN_ANSIBLE_DOC` - Set to `False` to skip `ansible-doc`. Defaults to `True`.

  - `RUN_ANSIBLE_LINT` - Set to `False` to skip running `ansible-lint --profile production` over the whole collection. Defaults to `True`.

  - `RUN_ANSIBLE_TEST` - Set to `True` to run `ansible-test` during collection import. Defaults to `False`.

  - `RUN_FLAKE8` - Set to `True` to run flake8. Defaults to `False`.




  To file an issue, visit the [Automation Hub Jira project](https://issues.redhat.com/projects/AAH/issues)

  Process details for `galaxy-importer`: [PROCESS.md](PROCESS.md)




  Place `.md` files in the `docs/` dir to have them show up in an imported collection's "Documentation" tab on Galaxy or Automation Hub.


pkgId: 30664099451c0729f49a264045d6679438c8f0d26624a79e27bfe16746041ad1
name: python-galileo-observe-help
arch: noarch
version: 1.15.2
epoch: 0
release: 1
summary: Development documents and examples for galileo-observe
url: https://pypi.org/project/galileo-observe/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-galileo-observe-1.15.2-1.src.rpm
location_href: Packages/python-galileo-observe-help-1.15.2-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/rungalileo/observe/graph/badge.svg?token=LWUTABNJHX)](https://codecov.io/gh/rungalileo/observe)

  Client library for logging calls from LLMs to Galileo Observe.


pkgId: 146b98dbb83d94e5f633f6d5616ce80da51da63d0eb09f34fad0eef7b4c3d949
name: python-gallia-help
arch: noarch
version: 1.9.0
epoch: 0
release: 1
summary: Development documents and examples for gallia
url: https://github.com/Fraunhofer-AISEC/gallia
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gallia-1.9.0-1.src.rpm
location_href: Packages/python-gallia-help-1.9.0-1.noarch.rpm
checksum_type: sha256
description:
  <!--
  SPDX-FileCopyrightText: AISEC Pentesting Team

  SPDX-License-Identifier: CC0-1.0
  -->



  [![docs](https://img.shields.io/badge/-docs-green)](https://fraunhofer-aisec.github.io/gallia)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/gallia)](https://pypi.python.org/pypi/gallia/)
  [![PyPI - License](https://img.shields.io/pypi/l/gallia)](https://www.apache.org/licenses/LICENSE-2.0.html)
  [![PyPI](https://img.shields.io/pypi/v/gallia)](https://pypi.python.org/pypi/gallia/)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10696368.svg)](https://zenodo.org/doi/10.5281/zenodo.10696368)

  [![Packaging status](https://repology.org/badge/vertical-allrepos/gallia.svg)](https://repology.org/project/gallia/versions)

  Gallia is an extendable pentesting framework with the focus on the automotive domain.
  The scope of the toolchain is conducting penetration tests from a single ECU up to whole cars.
  Currently, the main focus lies on the [UDS](https://www.iso.org/standard/72439.html) interface.
  Acting as a generic interface, the logging functionality implements reproducible tests and enables post-processing tasks.
  The [rendered documentation](https://fraunhofer-aisec.github.io/gallia) is available via Github Pages.

  Keep in mind that this project is intended for research and development usage only!
  Inappropriate usage might cause irreversible damage to the device under test.
  We do not take any responsibility for damage caused by the usage of this tool.



  See the [setup instructions](https://fraunhofer-aisec.github.io/gallia/setup.html).

  First create a config template with `--template`, store it to a file called [`gallia.toml`](https://fraunhofer-aisec.github.io/gallia/config.html), and adjust it to your needs.
  `gallia` reads this file to set the defaults of the command line flags.
  All options correspond to a command line flag; the only required option for scans is `gallia.scanner.target`, for instance `isotp://can0?src_addr=0x123&dst_addr=0x312&tx_padding=0xaa&rx_padding=0xaa`.

  ```
  $ gallia --template > gallia.toml
  ```

  You are all set to start your first scan, for instance read the diagnostic trouble codes:

  ```
  $ gallia primitive uds dtc read
  ```

  The target can also be specified by the `--target` option on the command line.
  For the format of the `--target` argument see the [transports documentation](https://fraunhofer-aisec.github.io/gallia/transports.html).



  This work was partly funded by the German Federal Ministry of Education and Research (BMBF) as part of the [SecForCARs](https://www.secforcars.de/) project (grant no. 16KIS0790).
  A short presentation and demo video is available at this [page](https://www.secforcars.de/demos/10-automotive-scanning-framework.html).


pkgId: 9c42fc892661dea021f36bd6720513ef25256c60be67f493ae993ea212611084
name: python-gama-cli-help
arch: noarch
version: 2.15.0
epoch: 0
release: 1
summary: Development documents and examples for gama-cli
url: https://github.com/Greenroom-Robotics/gama
rpm_license: Copyright (C) 2023, Greenroom Robotics
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gama-cli-2.15.0-1.src.rpm
location_href: Packages/python-gama-cli-help-2.15.0-1.noarch.rpm
checksum_type: sha256
description:
  ![GAMA CLI](./docs/gama_cli.png)

  Publicly available on [PyPi](https://pypi.org/project/gama-cli/) for convenience but if you don't work at Greenroom Robotics, you probably don't want to use this.



  * For development:
    * `pip install -e ./libs/gama_config`
    * `pip install -e ./tools/gama_cli`
  * For production: `pip install gama-cli`
  * You may also need to `export PATH=$PATH:~/.local/bin` if you don't have `~/.local/bin` in your path
  * Install autocomplete:
    * bash: `echo 'eval "$(_GAMA_CLI_COMPLETE=bash_source gama)"' >> ~/.bashrc`
    * zsh: `echo 'eval "$(_GAMA_CLI_COMPLETE=zsh_source gama)"' >> ~/.zshrc` (this is much nicer)



  * `gama --help` to get help with the CLI



  Installing a GAMA on a groundstation is as simple as this:

  * `mkdir ~/gama && cd ~/gama`
  * `gama authenticate` to authenticate with the GAMA package registry
  * `gama gs configure` to configure GAMA on a groundstation
  * `gama gs install` to install GAMA on a groundstation
  * `gama gs up` to start GAMA on a groundstation
  * `gama gs down` to stop GAMA on a groundstation



  Installing a GAMA on a vessel is as simple as this:

  * `mkdir ~/gama && cd ~/gama`
  * `gama authenticate` to authenticate with the GAMA package registry
  * `gama vessel configure` to configure GAMA on a vessel
  * `gama vessel install` to install GAMA on a vessel
  * `gama vessel up` to start GAMA on a vessel
  * `gama vessel down` to stop GAMA on a vessel



  GAMA CLI can be ran in dev mode. This will happen if it is installed with `pip install -e ./tools/gama_cli` or if the environment variable `GAMA_CLI_DEV_MODE` is set to `true`.


pkgId: 3769a753a838c13efeb6be3db585c362db41a5e2021d0ca8c785c479957c28ca
name: python-gammarer.aws-daily-cost-usage-reporter-help
arch: noarch
version: 1.2.19
epoch: 0
release: 1
summary: Development documents and examples for gammarer.aws-daily-cost-usage-reporter
url: https://github.com/gammarers/aws-daily-cost-usage-reporter.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarer.aws-daily-cost-usage-reporter-1.2.19-1.src.rpm
location_href: Packages/python-gammarer.aws-daily-cost-usage-reporter-help-1.2.19-1.noarch.rpm
checksum_type: sha256
description:
  AWS Cost And Usage report to Slack on daily 09:01.

  * Report type

    * Services

      * This is Cost by AWS Services.
    * Accounts

      * This is Cost by Linked Account (when organization master account)



  This construct creating resource list.

  * Lambda function execution role
  * Lambda function
  * EventBridge Scheduler execution role
  * EventBridge Scheduler





  ```shell
  npm install @gammarer/aws-daily-cost-usage-repoter

  yarn add @gammarer/aws-daily-cost-usage-repoter
  ```



  ```shell
  pip install gammarer.aws-daily-cost-usage-repoter
  ```



  ```shell
  npm install @gammarer/aws-daily-cost-usage-repoter
  ```

  ```python
  import { CostGroupType, DailyCostUsageReporter } from '@gammarer/aws-daily-cost-usage-repoter';

  new DailyCostUsageReporter(stack, 'DailyCostUsageReporter', {
    slackWebhookUrl: 'https://hooks.slack.com/services/xxxxxxxxxx', // already created slack webhook url
    slackPostChannel: 'example-channel', // already created slack channel
    costGroupType: CostGroupType.SERVICES,
  });
  ```



  This project is licensed under the Apache-2.0 License.


pkgId: 9aafcf2d500a55a78a147bfc00d962a299f980ac19631b194e022e5873487dc5
name: python-gammarers.aws-budgets-notification-help
arch: noarch
version: 1.2.30
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-budgets-notification
url: https://github.com/gammarers/aws-budgets-notification.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-budgets-notification-1.2.30-1.src.rpm
location_href: Packages/python-gammarers.aws-budgets-notification-help-1.2.30-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-budgets-notification?style=flat-square)](https://github.com/gammarers/aws-budgets-notification/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-budgets-notification?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-budgets-notification)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-budgets-notification?style=flat-square)](https://pypi.org/project/gammarers.aws-budgets-notification/)
  [![Nuget](https://img.shields.io/nuget/v/gammarers.CDK.AWS.BudgetNotification?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.BudgetNotification/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-budgets-notification/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-budgets-notification/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-budgets-notification?sort=semver&style=flat-square)](https://github.com/gammarers/aws-budgets-notification/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-budgets-notification)](https://constructs.dev/packages/@gammarers/aws-budgets-notification)

  A construct library for creating AWS Budgets Notification to Slack with the AWS CDK.



  This construct creating resource list.

  * SNS Topic
  * ChatBot SlackChannelConfiguration
  * Budgets (linked account count or self)





  ```shell
  npm install @gammarers/aws-budgets-notification

  yarn add @gammarers/aws-budgets-notification
  ```



  ```shell
  pip install gammarers.aws-budgets-notification
  ```



  ```shell
  dotnet add package Gammarers.CDK.AWS.BudgetNotification
  ```



  ```python
  import { BudgetsNotification } from '@gammarers/aws-budgets-notification';

  new BudgetsNotification(stack, 'BudgetsNotification', {
    slackWorkspaceId: 'T0XXXX111', // already AWS account linked your Slack.
    slackChannelId: 'XXXXXXXX', // already created your slack channel.
    budgetLimitAmount: 50,
    // optional linked account list
    linkedAccounts: [
      '111111111111',
      '222222222222',
    ],
  });
  ```

  ![example notification](./docs/slack-notification-image.png)



  This project is licensed under the Apache-2.0 License.


pkgId: 03fe2ac016b73a67a47fb1fd4a1edbe1f9d98923e82dbe31a90d65c78b2d9c2d
name: python-gammarers.aws-daily-cloud-watch-logs-archive-stack-help
arch: noarch
version: 2.8.17
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-daily-cloud-watch-logs-archive-stack
url: https://github.com/gammarers/aws-daily-cloud-watch-logs-archive-stack.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-daily-cloud-watch-logs-archive-stack-2.8.17-1.src.rpm
location_href: Packages/python-gammarers.aws-daily-cloud-watch-logs-archive-stack-help-2.8.17-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-daily-cloud-watch-logs-archive-stack?style=flat-square)](https://github.com/gammarers/aws-daily-cloud-watch-logs-archive-stack/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-daily-cloud-watch-logs-archive-stack?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-daily-cloud-watch-logs-archive-stack)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-daily-cloud-watch-logs-archive-stack?style=flat-square)](https://pypi.org/project/gammarers.aws-daily-cloud-watch-logs-archive-stack/)
  [![Nuget](https://img.shields.io/nuget/v/gammarers.CDK.AWS.DailyCloudWatchLogsArchiveStack?style=flat-square)](https://www.nuget.org/packages/gammarers.CDK.AWS.DailyCloudWatchLogsArchiveStack/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-daily-cloud-watch-logs-archive-stack/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-daily-cloud-watch-logs-archive-stack/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-daily-cloud-watch-logs-archive-stack?sort=semver&style=flat-square)](https://github.com/gammarers/aws-daily-cloud-watch-logs-archive-stack/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-daily-cloud-watch-logs-archive-stack)](https://constructs.dev/packages/@gammarers/aws-daily-cloud-watch-logs-archive-stack)

  AWS CloudWatch Logs daily(13:00Z) archive to s3 bucket.



  This construct creating resource list.

  * S3 Bucket (log-archive-xxxxxxxx from @gammarers/aws-secure-log-bucket)
  * Lambda function execution role
  * Lambda function
  * Lambda function log group
  * StepFunctions state machine execution role
  * StepFunctions state machine
  * EventBridge Scheduler execution role
  * EventBridge Scheduler



  ![architecture](/architecture.drawio.svg)







  ```shell
  npm install @gammarers/aws-daily-cloud-watch-logs-archive-stack
  ```



  ```shell
  yarn add @gammarers/aws-daily-cloud-watch-logs-archive-stack
  ```



  ```shell
  pnpm add @gammarers/aws-daily-cloud-watch-logs-archive-stack
  ```



  ```shell
  bun add @gammarers/aws-daily-cloud-watch-logs-archive-stack
  ```



  ```shell
  pip install gammarers.aws-daily-cloud-watch-logs-archive-stack
  ```



  ```shell
  dotnet add package Gammarers.CDK.AWS.DailyCloudWatchLogsArchiveStack
  ```



  ```shell
  npm install @gammarers/aws-daily-cloud-watch-logs-archive-stack
  ```

  ```python
  import { DailyCloudWatchLogsArchiveStack } from '@gammarers/aws-daily-cloud-watch-logs-archive-stack';

  new DailyCloudWatchLogsArchiveStack(stack, 'DailyCloudWatchLogsArchiveStack', {
      targetResourceTag: {
        key: 'DailyLogExport',
        values: ['Yes'],
      },
  });
  ```



  If you want to export old log files, please refer to the following repository. The log file will be exported in the same output format.

  [AWS CloudWatch Logs Exporter](https://github.com/gammarers/aws-cloud-watch-logs-exporter)



  This project is licensed under the Apache-2.0 License.


pkgId: d5f41fb2c46e99dcc441cf36d7f6bb087e8d1beb29b9a96b451baa57f880778f
name: python-gammarers.aws-ec2-instance-running-schedule-stack-help
arch: noarch
version: 2.0.6
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-ec2-instance-running-schedule-stack
url: https://github.com/gammarers/aws-ec2-instance-running-schedule-stack.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-ec2-instance-running-schedule-stack-2.0.6-1.src.rpm
location_href: Packages/python-gammarers.aws-ec2-instance-running-schedule-stack-help-2.0.6-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-ec2-instance-running-schedule-stack?style=flat-square)](https://github.com/gammarers/aws-ec2-instance-running-schedule-stack/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-ec2-instance-running-schedule-stack?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-ec2-instance-running-schedule-stack)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-ec2-instance-running-schedule-stack?style=flat-square)](https://pypi.org/project/gammarers.aws-ec2-instance-running-schedule-stack/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.EC2InstanceRunningScheduleStack?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.EC2InstanceRunningScheduleStack/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-ec2-instance-running-schedule-stack/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-ec2-instance-running-schedule-stack/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-ec2-instance-running-schedule-stack?sort=semver&style=flat-square)](https://github.com/gammarers/aws-ec2-instance-running-schedule-stack/releases)

  This is an AWS CDK Construct to make EC2 instance running schedule (only running while working hours(start/stop)).



  * EC2 Instance



  This construct creating resource list.

  * EventBridge Scheduler execution role
  * EventBridge Scheduler
  * Step Functions State machine
  * Step Functions State machine role







  ```shell
  npm install @gammarer/aws-ec2-instance-running-schedule-stack
  ```



  ```shell
  yarn add @gammarer/aws-ec2-instance-running-schedule-stack
  ```



  ```shell
  pip install gammarer.aws-ec2-instance-running-schedule-stack
  ```



  ```shell
  dotnet add package Gammarer.CDK.AWS.Ec2InstanceRunningScheduleStack
  ```



  ```python
  import { Ec2InstanceRunningScheduleStack } from '@gammarer/aws-ec2-instance-running-schedule-stack';

  new EC2InstanceRunningScheduleStack(app, 'EC2InstanceRunningScheduleStack', {
    targetResource: {
      tagKey: 'WorkHoursRunning',
      tagValues: ['YES'],
    },
    startSchedule: {
      timezone: 'Asia/Tokyo',
      minute: '55',
      hour: '8',
      week: 'MON-FRI',
    },
    stopSchedule: {
      timezone: 'Asia/Tokyo',
      minute: '5',
      hour: '19',
      week: 'MON-FRI',
    },
  });
  ```



  This project is licensed under the Apache-2.0 License.


pkgId: 83fbbb98fb86f96039d21522699283a20b305784a78172205bf68da627951497
name: python-gammarers.aws-frontend-web-app-deploy-stack-help
arch: noarch
version: 1.3.18
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-frontend-web-app-deploy-stack
url: https://github.com/gammarers/aws-frontend-web-app-deploy-stack.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-frontend-web-app-deploy-stack-1.3.18-1.src.rpm
location_href: Packages/python-gammarers.aws-frontend-web-app-deploy-stack-help-1.3.18-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-frontend-web-app-deploy-stack?style=flat-square)](https://github.com/gammarers/aws-frontend-web-app-deploy-stack/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-frontend-web-app-deploy-stack?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-frontend-web-app-deploy-stack)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-frontend-web-app-deploy-stack?style=flat-square)](https://pypi.org/project/gammarers.aws-frontend-web-app-deploy-stack/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.FrontendWebAppDeployStack?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.FrontendWebAppDeployStack/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-frontend-web-app-deploy-stack/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-frontend-web-app-deploy-stack/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-frontend-web-app-deploy-stack?sort=semver&style=flat-square)](https://github.com/gammarers/aws-frontend-web-app-deploy-stack/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-frontend-web-app-deploy-stack)](https://constructs.dev/packages/@gammarers/aws-frontend-web-app-deploy-stack)

  This is an AWS CDK Construct to make deploying a Frontend Web App (SPA) deploy to S3 behind CloudFront.







  ```shell
  npm install @gammarers/aws-frontend-web-app-deploy-stack
  ```



  ```shell
  yarn add @gammarers/aws-frontend-web-app-deploy-stack
  ```



  ```shell
  pnpm add @gammarers/aws-frontend-web-app-deploy-stack
  ```



  ```shell
  bun add @gammarers/aws-frontend-web-app-deploy-stack
  ```



  ```shell
  pip install gammarers.aws-frontend-web-app-deploy-stack
  ```



  ```shell
  dotnet add package Gammarers.CDK.AWS.FrontendWebAppDeployStack
  ```



  ```python
  import { FrontendWebAppDeployStack } from '@gammarers/aws-frontend-web-app-deploy-stack';

  new FrontendWebAppDeployStack(app, 'FrontendWebAppDeployStack', {
    env: { account: '012345678901', region: 'us-east-1' },
    domainName: 'example.com',
    hostedZoneId: 'Z0000000000000000000Q',
    originBucketName: 'frontend-web-app-example-origin-bucket', // new create in this stack
    deploySourceAssetPath: 'website/',
    logBucketArn: 'arn:aws:s3:::frontend-web-app-example-access-log-bucket', // already created
  });
  ```



  This project is licensed under the Apache-2.0 License.


pkgId: ba1de887bd5e6402f34e09357ef6d544a79cbf673b32004bc6f47f82e784317e
name: python-gammarers.aws-secure-bucket-help
arch: noarch
version: 2.0.27
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-secure-bucket
url: https://github.com/gammarers/aws-secure-bucket.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-secure-bucket-2.0.27-1.src.rpm
location_href: Packages/python-gammarers.aws-secure-bucket-help-2.0.27-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-secure-bucket?style=flat-square)](https://github.com/gammarers/aws-secure-bucket/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-secure-bucket?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-secure-bucket)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-secure-bucket?style=flat-square)](https://pypi.org/project/gammarers.aws-secure-bucket/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.SecureBucket?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.SecureBucket/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-secure-bucket/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-secure-bucket/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-secure-bucket?sort=semver&style=flat-square)](https://github.com/gammarers/aws-secure-bucket/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-secure-bucket)](https://constructs.dev/packages/@gammarers/aws-secure-bucket)

  This is a Simple S3 Secure Bucket.

  * Bucket Access Control is Private
  * Public Read Access is false
  * Enforce SSL
  * All Block public access
  * Require encryption







  ```shell
  npm install @gammarers/aws-secure-bucket
  ```



  ```shell
  yarn add @gammarers/aws-secure-bucket
  ```



  ```shell
  pnpm add @gammarers/aws-secure-bucket
  ```



  ```shell
  bun add @gammarers/aws-secure-bucket
  ```



  ```shell
  pip install gammarers.aws-secure-bucket
  ```



  ```shell
  dotnet add package Gammarers.CDK.AWS.SecureBucket
  ```



  ```python
  import { SecureBucket } from '@gammarers/aws-secure-bucket';

  const bucket = new SecureBucket(stack, 'SecureBucket', {
    bucketName: 'example-secure-bucket',
  });
  ```


pkgId: d8b975a6c198eee07d2e2003396121ce03ac2cc4a7e940dfb6e16b9c524045aa
name: python-gammarers.aws-secure-cloudfront-origin-bucket-help
arch: noarch
version: 2.1.6
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-secure-cloudfront-origin-bucket
url: https://github.com/gammarers/aws-secure-cloudfront-origin-bucket.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-secure-cloudfront-origin-bucket-2.1.6-1.src.rpm
location_href: Packages/python-gammarers.aws-secure-cloudfront-origin-bucket-help-2.1.6-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-secure-cloudfront-origin-bucket?style=flat-square)](https://github.com/gammarers/aws-secure-cloudfront-origin-bucket/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-secure-cloudfront-origin-bucket?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-secure-cloudfront-origin-bucket)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-secure-cloudfront-origin-bucket?style=flat-square)](https://pypi.org/project/gammarers.aws-secure-cloudfront-origin-bucket/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.SecureCloudFrontOriginBucket?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.ScureCloudFrontOriginBucket/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-secure-cloudfront-origin-bucket/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-secure-cloudfront-origin-bucket/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-secure-cloudfront-origin-bucket?sort=semver&style=flat-square)](https://github.com/gammarers/aws-secure-cloudfront-origin-bucket/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-secure-cloudfront-origin-bucket)](https://constructs.dev/packages/@gammarers/aws-secure-cloudfront-origin-bucket)

  An AWS CDK construct library to create secure S3 buckets for CloudFront origin.

  > [!WARNING]
  > v2.1.0: remove origin access identity(oai) support







  ```shell
  npm install @gammarers/aws-secure-cloudfront-origin-bucket
  ```



  ```shell
  yarn add @gammarers/aws-secure-cloudfront-origin-bucket
  ```



  ```shell
  pnpm add @gammarers/aws-secure-cloudfront-origin-bucket
  ```



  ```shell
  bun add @gammarers/aws-secure-cloudfront-origin-bucket
  ```



  ```shell
  pip install gammarers.aws-secure-cloudfront-origin-bucket
  ```



  ```shell
  dotnet add package gammarers.CDK.AWS.SecureCloudFrontOriginBucket
  ```





  ```python
  import { SecureCloudFrontOriginBucket, SecureCloudFrontOriginType } from '@gammarers/aws-secure-cloudfront-origin-bucket';

  const originBucket = new SecureCloudFrontOriginBucket(stack, 'SecureCloudFrontOriginBucket', {
    bucketName: 'example-origin-bucket',
  });

  const distribution = new cloudfront.Distribution(this, 'Distribution', {
    defaultRootObject: 'index.html',
    defaultBehavior: {
      origin: origins.S3BucketOrigin.withOriginAccessControl(originBucket),
    },
  });
  ```



  This project is licensed under the Apache-2.0 License.


pkgId: f43bb5959e8b2461117d3db1f95e3f5d61580c9f068fd9758b5187cb830d39e0
name: python-gammarers.aws-secure-frontend-web-app-cloudfront-distribution-help
arch: noarch
version: 1.4.26
epoch: 0
release: 1
url: https://github.com/gammarers/aws-secure-frontend-web-app-cloudfront-distribution.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-secure-frontend-web-app-cloudfront-distribution-1.4.26-1.src.rpm
checksum_type: sha256
summary:
  Development documents and examples for gammarers.aws-secure-frontend-web-app-cloudfront-distribution

description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-secure-frontend-web-app-cloudfront-distribution?style=flat-square)](https://github.com/gammarers/aws-secure-frontend-web-app-cloudfront-distribution/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-secure-frontend-web-app-cloudfront-distribution?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-secure-frontend-web-app-cloudfront-distribution)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-secure-frontend-web-app-cloudfront-distribution?style=flat-square)](https://pypi.org/project/gammarers.aws-secure-frontend-web-app-cloudfront-distribution/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.SecureFrontendWebAppCloudFrontDistribution?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.SecureFrontendWebAppCloudFrontDistribution/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-secure-frontend-web-app-cloudfront-distribution/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-secure-frontend-web-app-cloudfront-distribution/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-secure-frontend-web-app-cloudfront-distribution?sort=semver&style=flat-square)](https://github.com/gammarers/aws-secure-frontend-web-app-cloudfront-distribution/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-secure-frontend-web-app-cloudfront-distribution)](https://constructs.dev/packages/@gammarers/aws-secure-frontend-web-app-cloudfront-distribution)

  AWS CloudFront distribution for frontend web app (spa) optimized.





  ```shell
  npm install @gammarers/aws-secure-frontend-web-app-cloudfront-distribution

  yarn add @gammarers/aws-secure-frontend-web-app-cloudfront-distribution
  ```



  ```shell
  pip install gammarers.aws-secure-frontend-web-app-cloudfront-distribution
  ```



  ```shell
  dotnet add package Gammarers.CDK.AWS.SecureFrontendWebAppCloudFrontDistribution
  ```





  ```python
  import { SecureFrontendWebAppCloudFrontDistribution, S3OriginAccessType } from '@gammarers/aws-secure-frontend-web-app-cloudfront-distribution';

  declare const originBucket: s3.Bucket;
  declare const accessLogBucket: s3.Bucket;
  declare const certificate: acm.Certificate;
  declare const cfnOriginAccessControl: cloudfront.CfnOriginAccessControl

  new SecureFrontendWebAppCloudFrontDistribution(stack, 'SecureFrontendWebAppCloudFrontDistribution', {
    comment: 'frontend web app distribution.', // optional
    accessLogBucket: accessLogBucket, // optional
    certificate: certificate,
    distributionDomainName: 'example.com',
    s3OriginAccessType: S3OriginAccessType.ORIGIN_ACCESS_CONTROL,
    originAccessControlId: cfnOriginAccessControl.attrId,
    originBucket: originBucket,
  });
  ```



  ```python
  import { SecureFrontendWebAppCloudFrontDistribution, S3OriginAccessType } from '@gammarers/aws-secure-frontend-web-app-cloudfront-distribution';

  declare const originBucket: s3.Bucket;
  declare const accessLogBucket: s3.Bucket;
  declare const certificate: acm.Certificate;
  declare const originAccessIdentity: cloudfront.OriginAccessIdentity;

  new SecureFrontendWebAppCloudFrontDistribution(stack, 'SecureFrontendWebAppCloudFrontDistribution', {
    comment: 'frontend web app distribution.', // optional
    accessLogBucket: accessLogBucket, // optional
    certificate: certificate,
    distributionDomainName: 'example.com',
    s3OriginAccessType: S3OriginAccessType.ORIGIN_ACCESS_IDENTITY,
    originAccessIdentity: originAccessIdentity,
    originBucket: originBucket,
  });
  ```



  This project is licensed under the Apache-2.0 License.

location_href:
  Packages/python-gammarers.aws-secure-frontend-web-app-cloudfront-distribution-help-1.4.26-1.noarch.rpm


pkgId: 343f98d8fb62356639595df3e658893191d84bb1a1725bc7e919a7fc462e0466
name: python-gammarers.aws-secure-log-bucket-help
arch: noarch
version: 2.0.26
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-secure-log-bucket
url: https://github.com/gammarers/aws-secure-log-bucket.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-secure-log-bucket-2.0.26-1.src.rpm
location_href: Packages/python-gammarers.aws-secure-log-bucket-help-2.0.26-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/yicr/aws-secure-log-bucket?style=flat-square)](https://github.com/yicr/aws-secure-log-bucket/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-secure-log-bucket?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-secure-log-bucket)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-secure-log-bucket?style=flat-square)](https://pypi.org/project/gammarers.aws-secure-log-bucket/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.SecureLogBucket?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.SecureLogBucket/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/yicr/aws-secure-log-bucket/release.yml?branch=main&label=release&style=flat-square)](https://github.com/yicr/aws-secure-log-bucket/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/yicr/aws-secure-log-bucket?sort=semver&style=flat-square)](https://github.com/yicr/aws-secure-log-bucket/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-secure-log-bucket)](https://constructs.dev/packages/@gammarers/aws-secure-log-bucket)

  secure multiple transition phases in a single lifecycle policy bucket.



  The storage class will be changed with the following lifecycle configuration.

  | Storage Class       | Defaul transition after days |
  | ------------------- |------------------------------|
  | INFREQUENT_ACCESS   | 400 days                     |
  | GLACIER             | 720 days                     |
  | DEEP_ARCHIVE        | 980 days                     |







  ```shell
  npm install @gammarers/aws-secure-log-bucket
  ```



  ```shell
  yarn add @gammarers/aws-secure-log-bucket
  ```



  ```shell
  pnpm add @gammarers/aws-secure-log-bucket
  ```



  ```shell
  bun add @gammarers/aws-secure-log-bucket
  ```



  ```shell
  pip install gammarers.aws-secure-log-bucket
  ```



  ```shell
  dotnet add package Gammarers.CDK.AWS.SecureLogBucket
  ```



  ```python
  import { SecureLogBucket } from '@gammarers/aws-secure-log-bucket';

  new SecureLogBucket(stack, 'SecureLogBucket');
  ```



  This project is licensed under the Apache-2.0 License.


pkgId: 24dc37b4865b8b3d8f0e25223baa7b72ea9611cbbfaa7391eb199b86e0c8b69c
name: python-gammarers.aws-secure-vpc-bucket-help
arch: noarch
version: 1.4.29
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-secure-vpc-bucket
url: https://github.com/gammarers/aws-secure-vpc-bucket.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-secure-vpc-bucket-1.4.29-1.src.rpm
location_href: Packages/python-gammarers.aws-secure-vpc-bucket-help-1.4.29-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-secure-vpc-bucket?style=flat-square)](https://github.com/gammarers/aws-secure-vpc-bucket/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-secure-vpc-bucket?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-secure-vpc-bucket)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-secure-vpc-bucket?style=flat-square)](https://pypi.org/project/gammarers.aws-secure-vpc-bucket/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.SecureVpcBucket?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.SecureVpcBucket/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-secure-vpc-bucket/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-secure-vpc-bucket/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-secure-vpc-bucket?sort=semver&style=flat-square)](https://github.com/gammarers/aws-secure-vpc-bucket/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-secure-vpc-bucket)](https://constructs.dev/packages/@gammarers/aws-secure-vpc-bucket)

  Access from specific VPC Endpoint only Bucket





  ```shell
  npm install @gammarers/aws-secure-vpc-bucket
  ```

  or

  ```shell
  yarn add @gammarers/aws-secure-vpc-bucket
  ```

  or

  ```shell
  pnpm add @gammarers/aws-secure-vpc-bucket
  ```

  or

  ```shell
  bun add @gammarers/aws-secure-vpc-bucket
  ```



  ```shell
  pip install gammarers.aws-secure-vpc-bucket
  ```



  ```shell
  dotnet add package gammarers.CDK.AWS.SecureVpcBucket
  ```



  ```python
  import { SecureSpecificVpcOnlyBucket } from '@gammarers/aws-secure-vpc-bucket';

  new SecureVpcBucket(stack, 'SecureVpcBucket', {
    bucketName: 'example-origin-bucket',
    vpcEndpointId: 'vpce-0xxxxxxxxxxxxxxxx', // already created vpc endpoint id
  });
  ```



  This project is licensed under the Apache-2.0 License.


pkgId: 24356db76d191ab686d8503ad5d4530c928fabb20830a6d8a16fa0c9d73eee6a
name: python-gammarers.aws-waf-geo-restriction-rule-group-help
arch: noarch
version: 1.5.17
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-waf-geo-restriction-rule-group
url: https://github.com/gammarers/aws-waf-geo-restriction-rule-group.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-waf-geo-restriction-rule-group-1.5.17-1.src.rpm
location_href: Packages/python-gammarers.aws-waf-geo-restriction-rule-group-help-1.5.17-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-waf-geo-restriction-rule-group?style=flat-square)](https://github.com/gammarers/aws-waf-geo-restriction-rule-group/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-waf-geo-restriction-rule-group?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-waf-geo-restriction-rule-group)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-waf-geo-restriction-rule-group?style=flat-square)](https://pypi.org/project/gammarers.aws-waf-geo-restriction-rule-group/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.WafGeoRestrictionRuleGroup?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.WafGeoRestrictionRuleGroup/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-waf-geo-restriction-rule-group/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-waf-geo-restriction-rule-group/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-waf-geo-restriction-rule-group?sort=semver&style=flat-square)](https://github.com/gammarers/aws-waf-geo-restriction-rule-group/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-waf-geo-restriction-rule-group)](https://constructs.dev/packages/@gammarers/aws-waf-geo-restriction-rule-group)

  This is an AWS CDK Construct for Geo Restriction Rule Group on WAF V2



  This construct creating resource list.

  * WAF V2 RuleGroup







  ```shell
  npm install @gammarers/aws-waf-geo-restriction-rule-group
  ```



  ```shell
  yarn add @gammarers/aws-waf-geo-restriction-rule-group
  ```



  ```shell
  pnpm add @gammarers/aws-waf-geo-restriction-rule-group
  ```



  ```shell
  bun add @gammarers/aws-waf-geo-restriction-rule-group
  ```



  ```shell
  pip install gammarers.aws-waf-geo-restriction-rule-group
  ```



  ```shell
  dotnet add package Gammarers.CDK.AWS.WafGeoRestrictionRuleGroup
  ```



  ```python
  import { WafGeoRestrictRuleGroup } from '@gammarers/aws-waf-geo-restriction-rule-group';

  new WafGeoRestrictRuleGroup(stack, 'WafGeoRestrictRuleGroup', {
    scope: Scope.GLOBAL, // GLOBAL(CloudFront) or REGIONAL(Application Load Balancer (ALB), Amazon API Gateway REST API, an AWS AppSync GraphQL API, or an Amazon Cognito user pool)
    allowCountries: ['JP'], // alpha-2 country and region codes from the International Organization for Standardization (ISO) 3166 standard
  });
  ```



  This project is licensed under the Apache-2.0 License.


pkgId: b0b33d70b1d7cfd0f025aa10b00fbe3b73a12c905058ce3472ba970402620357
name: python-gammarers.aws-waf-ip-rate-limit-rule-group-help
arch: noarch
version: 1.4.17
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-waf-ip-rate-limit-rule-group
url: https://github.com/gammarers/aws-waf-ip-rate-limit-rule-group.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-waf-ip-rate-limit-rule-group-1.4.17-1.src.rpm
location_href: Packages/python-gammarers.aws-waf-ip-rate-limit-rule-group-help-1.4.17-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-waf-ip-rate-limit-rule-group?style=flat-square)](https://github.com/gammarers/aws-waf-ip-rate-limit-rule-group/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-waf-ip-rate-limit-rule-group?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-waf-ip-rate-limit-rule-group)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-waf-ip-rate-limit-rule-group?style=flat-square)](https://pypi.org/project/gammarers.aws-waf-ip-rate-limit-rule-group/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.WafIpRateLimitRuleGroup?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.WafIpRateLimitRuleGroup/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-waf-ip-rate-limit-rule-group/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-waf-ip-rate-limit-rule-group/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-waf-ip-rate-limit-rule-group?sort=semver&style=flat-square)](https://github.com/gammarers/aws-waf-ip-rate-limit-rule-group/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-waf-ip-rate-limit-rule-group)](https://constructs.dev/packages/@gammarers/aws-waf-ip-rate-limit-rule-group)

  This is an AWS CDK Construct for IP Rate Limit Rule on WAF V2



  This construct creating resource list.

  * WAF V2 RuleGroup





  ```shell


  ```



  ```shell
  npm install @gammarers/aws-waf-ip-rate-limit-rule-group
  ```



  ```shell
  yarn add @gammarers/aws-waf-ip-rate-limit-rule-group
  ```



  ```shell
  pnpm add @gammarers/aws-waf-ip-rate-limit-rule-group
  ```



  ```shell
  bun add @gammarers/aws-waf-ip-rate-limit-rule-group
  ```



  ```shell
  pip install gammarers.aws-waf-ip-rate-limit-rule-group
  ```



  ```shell
  dotnet add package Gammarers.CDK.AWS.WafIpRateLimitRuleGroup
  ```



  ```python
  import { Scope, WafRateLimitRuleGroup } from '@gammarers/aws-waf-ip-rate-limit-rule-group';

  new WafIpRateLimitRuleGroup(stack, 'WafIpRateLimitRuleGroup', {
    name: 'rate-limit-rule-group',
    scope: Scope.REGIONAL,
    rateLimitCount: 3000, // default 1000
  });
  ```



  This project is licensed under the Apache-2.0 License.


pkgId: 327ac0b1f02dc07652d04133b9875b620f936e4bff3e4f22483fd6b842571127
name: python-gammarers.aws-waf-ip-restriction-rule-group-help
arch: noarch
version: 1.5.17
epoch: 0
release: 1
summary: Development documents and examples for gammarers.aws-waf-ip-restriction-rule-group
url: https://github.com/gammarers/aws-waf-ip-restriction-rule-group.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gammarers.aws-waf-ip-restriction-rule-group-1.5.17-1.src.rpm
location_href: Packages/python-gammarers.aws-waf-ip-restriction-rule-group-help-1.5.17-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/gammarers/aws-waf-ip-restriction-rule-group?style=flat-square)](https://github.com/gammarers/aws-waf-ip-restriction-rule-group/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@gammarers/aws-waf-ip-restriction-rule-group?style=flat-square)](https://www.npmjs.com/package/@gammarers/aws-waf-ip-restriction-rule-group)
  [![PyPI](https://img.shields.io/pypi/v/gammarers.aws-waf-ip-restriction-rule-group?style=flat-square)](https://pypi.org/project/gammarers.aws-waf-ip-restriction-rule-group/)
  [![Nuget](https://img.shields.io/nuget/v/Gammarers.CDK.AWS.WafIpRestrictionRuleGroup?style=flat-square)](https://www.nuget.org/packages/Gammarers.CDK.AWS.WafIpRestrictionRuleGroup/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/gammarers/aws-waf-ip-restriction-rule-group/release.yml?branch=main&label=release&style=flat-square)](https://github.com/gammarers/aws-waf-ip-restriction-rule-group/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/gammarers/aws-waf-ip-restriction-rule-group?sort=semver&style=flat-square)](https://github.com/gammarers/aws-waf-ip-restriction-rule-group/releases)

  [![View on Construct Hub](https://constructs.dev/badge?package=@gammarers/aws-waf-ip-restriction-rule-group)](https://constructs.dev/packages/@gammarers/aws-waf-ip-restriction-rule-group)

  This is an AWS CDK Construct for IP Restriction Rule Group on WAF V2



  This construct creating resource list.

  * WAF V2 RuleGroup







  ```shell
  npm install @gammarers/aws-waf-ip-restriction-rule-group
  ```



  ```shell
  yarn add @gammarers/aws-waf-ip-restriction-rule-group
  ```



  ```shell
  pnpm add @gammarers/aws-waf-ip-restriction-rule-group
  ```



  ```shell
  bun add @gammarers/aws-waf-ip-restriction-rule-group
  ```



  ```shell
  pip install gammarers.aws-waf-ip-restriction-rule-group
  ```



  ```shell
  dotnet add package Gammarers.CDK.AWS.WafIpRestrictionRuleGroup
  ```



  ```python
  import { WafIpRestrictRuleGroup } from '@gammarers/aws-waf-ip-restriction-rule-group';

  declare const allowIpSet: waf.CfnIPSet;

  new WafIpRestrictRuleGroup(stack, 'WafIpRestrictRuleGroup', {
    scope: Scope.GLOBAL, // GLOBAL(CloudFront) or REGIONAL(Application Load Balancer (ALB), Amazon API Gateway REST API, an AWS AppSync GraphQL API, or an Amazon Cognito user pool)
    allowIpSetArn: allowIpSet.attrArn,
  });
  ```



  This project is licensed under the Apache-2.0 License.


pkgId: 862b5255e3bdb151d76198214c69768ff30f02a5eef7c7570e6e79dffb29ee1d
name: python-gandula-help
arch: noarch
version: 0.2.7
epoch: 0
release: 1
summary: Development documents and examples for gandula
url: https://pypi.org/project/gandula/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gandula-0.2.7-1.src.rpm
location_href: Packages/python-gandula-help-0.2.7-1.noarch.rpm
checksum_type: sha256
description:
  `gandula` is a specialized internal Python library developed by the Sports Analytics lab at the Federal University of Minas Gerais (UFMG). Designed to streamline our research efforts, `gandula` currently offers tools to help handling PFF data.
  Gandula is the word for ball boy in brazilian portuguese. It originates from the 1930s, from the word "gandulo", that in archaic portuguese means slacker/beggar.
  Back in the 30s, the word started to be used to refer to vagabond boys, who didn't nothing else to do but watch football in the pitches in Rio. These "gandulas"
  would help by bringing the kicked out balls. In 1939, the Clube de Regatas Vasco da Gama hired the argentinian stricker Bernardo Gandulla, who was known to bring
  back the ball as a fair play. The `gandula` then got popularized over the country. In our `gandula`, the ball is the data, and the data scientists/analysts are

rpm_license:
  MIT License  Copyright (c) 2024 Thiago Costa Porto  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: 5ccd365291f175b48da6bb32af6b98e58992179b461ba4794c309f4ee5ba2c25
name: python-garak-help
arch: noarch
version: 0.10.1
epoch: 0
release: 1
summary: Development documents and examples for garak
url: https://github.com/NVIDIA/garak
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-garak-0.10.1-1.src.rpm
location_href: Packages/python-garak-help-0.10.1-1.noarch.rpm
checksum_type: sha256
description:
  *Generative AI Red-teaming & Assessment Kit*

  `garak` checks if an LLM can be made to fail in a way we don't want. `garak` probes for hallucination, data leakage, prompt injection, misinformation, toxicity generation, jailbreaks, and many other weaknesses. If you know `nmap`, it's `nmap` for LLMs.

  `garak` focuses on ways of making an LLM or dialog system fail. It combines static, dynamic, and adaptive probes to explore this.

  `garak`'s a free tool. We love developing it and are always interested in adding functionality to support applications.

  [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Tests/Linux](https://github.com/NVIDIA/garak/actions/workflows/test_linux.yml/badge.svg)](https://github.com/NVIDIA/garak/actions/workflows/test_linux.yml)
  [![Tests/Windows](https://github.com/NVIDIA/garak/actions/workflows/test_windows.yml/badge.svg)](https://github.com/NVIDIA/garak/actions/workflows/test_windows.yml)
  [![Tests/OSX](https://github.com/NVIDIA/garak/actions/workflows/test_macos.yml/badge.svg)](https://github.com/NVIDIA/garak/actions/workflows/test_macos.yml)
  [![Documentation Status](https://readthedocs.org/projects/garak/badge/?version=latest)](http://garak.readthedocs.io/en/latest/?badge=latest)
  [![arXiv](https://img.shields.io/badge/cs.CL-arXiv%3A2406.11036-b31b1b.svg)](https://arxiv.org/abs/2406.11036)
  [![discord-img](https://img.shields.io/badge/chat-on%20discord-yellow.svg)](https://discord.gg/uVch4puUCs)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/garak)](https://pypi.org/project/garak)
  [![PyPI](https://badge.fury.io/py/garak.svg)](https://badge.fury.io/py/garak)
  [![Downloads](https://pepy.tech/badge/garak)](https://pepy.tech/project/garak)
  [![Downloads](https://pepy.tech/badge/garak/month)](https://pepy.tech/project/garak)









  <hr>



  currently supports:
  * [hugging face hub](https://huggingface.co/models) generative models
  * [replicate](https://replicate.com/) text models
  * [openai api](https://platform.openai.com/docs/introduction) chat & continuation models
  * [litellm](https://www.litellm.ai/)
  * pretty much anything accessible via REST
  * gguf models like [llama.cpp](https://github.com/ggerganov/llama.cpp) version >= 1046
  * .. and many more LLMs!



  `garak` is a command-line tool. It's developed in Linux and OSX.



  Just grab it from PyPI and you should be good to go:

  ```
  python -m pip install -U garak
  ```



  The standard pip version of `garak` is updated periodically. To get a fresher version from GitHub, try:

  ```
  python -m pip install -U git+https://github.com/NVIDIA/garak.git@main
  ```



  `garak` has its own dependencies. You can to install `garak` in its own Conda environment:

  ```
  conda create --name garak "python>=3.10,<=3.12"
  conda activate garak
  gh repo clone NVIDIA/garak
  cd garak
  python -m pip install -e .
  ```

  OK, if that went fine, you're probably good to go!

  **Note**: if you cloned before the move to the `NVIDIA` GitHub organisation, but you're reading this at the `github.com/NVIDIA` URI, please update your remotes as follows:

  ```
  git remote set-url origin https://github.com/NVIDIA/garak.git
  ```




  The general syntax is:

  `garak <options>`

  `garak` needs to know what model to scan, and by default, it'll try all the probes it knows on that model, using the vulnerability detectors recommended by each probe. You can see a list of probes using:

  `garak --list_probes`

  To specify a generator, use the `--model_type` and, optionally, the `--model_name` options. Model type specifies a model family/interface; model name specifies the exact model to be used. The "Intro to generators" section below describes some of the generators supported. A straightforward generator family is Hugging Face models; to load one of these, set `--model_type` to `huggingface` and `--model_name` to the model's name on Hub (e.g. `"RWKV/rwkv-4-169m-pile"`). Some generators might need an API key to be set as an environment variable, and they'll let you know if they need that.

  `garak` runs all the probes by default, but you can be specific about that too. `--probes promptinject` will use only the [PromptInject](https://github.com/agencyenterprise/promptinject) framework's methods, for example. You can also specify one specific plugin instead of a plugin family by adding the plugin name after a `.`; for example, `--probes lmrc.SlurUsage` will use an implementation of checking for models generating slurs based on the [Language Model Risk Cards](https://arxiv.org/abs/2303.18190) framework.

  For help and inspiration, find us on [Twitter](https://twitter.com/garak_llm) or [discord](https://discord.gg/uVch4puUCs)!



  Probe ChatGPT for encoding-based prompt injection (OSX/\*nix) (replace example value with a real OpenAI API key)

  ```
  export OPENAI_API_KEY="sk-123XXXXXXXXXXXX"
  python3 -m garak --model_type openai --model_name gpt-3.5-turbo --probes encoding
  ```

  See if the Hugging Face version of GPT2 is vulnerable to DAN 11.0

  ```
  python3 -m garak --model_type huggingface --model_name gpt2 --probes dan.Dan_11_0
  ```




  For each probe loaded, garak will print a progress bar as it generates. Once generation is complete, a row evaluating that probe's results on each detector is given. If any of the prompt attempts yielded an undesirable behavior, the response will be marked as FAIL, and the failure rate given.

  Here are the results with the `encoding` module on a GPT-3 variant:
  ![alt text](https://i.imgur.com/8Dxf45N.png)

  And the same results for ChatGPT:
  ![alt text](https://i.imgur.com/VKAF5if.png)

  We can see that the more recent model is much more susceptible to encoding-based injection attacks, where text-babbage-001 was only found to be vulnerable to quoted-printable and MIME encoding injections.  The figures at the end of each row, e.g. 840/840, indicate the number of text generations total and then how many of these seemed to behave OK. The figure can be quite high because more than one generation is made per prompt - by default, 10.

  Errors go in `garak.log`; the run is logged in detail in a `.jsonl` file specified at analysis start & end. There's a basic analysis script in `analyse/analyse_log.py` which will output the probes and prompts that led to the most hits.

  Send PRs & open issues. Happy hunting!





  Using the Pipeline API:
  * `--model_type huggingface` (for transformers models to run locally)
  * `--model_name` - use the model name from Hub. Only generative models will work. If it fails and shouldn't, please open an issue and paste in the command you tried + the exception!

  Using the Inference API:
  * `--model_type huggingface.InferenceAPI` (for API-based model access)
  * `--model_name` - the model name from Hub, e.g. `"mosaicml/mpt-7b-instruct"`

  Using private endpoints:
  * `--model_type huggingface.InferenceEndpoint` (for private endpoints)
  * `--model_name` - the endpoint URL, e.g. `https://xxx.us-east-1.aws.endpoints.huggingface.cloud`

  * (optional) set the `HF_INFERENCE_TOKEN` environment variable to a Hugging Face API token with the "read" role; see https://huggingface.co/settings/tokens when logged in



  * `--model_type openai`
  * `--model_name` - the OpenAI model you'd like to use. `gpt-3.5-turbo-0125` is fast and fine for testing.
  * set the `OPENAI_API_KEY` environment variable to your OpenAI API key (e.g. "sk-19763ASDF87q6657"); see https://platform.openai.com/account/api-keys when logged in

  Recognised model types are whitelisted, because the plugin needs to know which sub-API to use. Completion or ChatCompletion models are OK. If you'd like to use a model not supported, you should get an informative error message, and please send a PR / open an issue.



  * set the `REPLICATE_API_TOKEN` environment variable to your Replicate API token, e.g. "r8-123XXXXXXXXXXXX"; see https://replicate.com/account/api-tokens when logged in

  Public Replicate models:
  * `--model_type replicate`
  * `--model_name` - the Replicate model name and hash, e.g. `"stability-ai/stablelm-tuned-alpha-7b:c49dae36"`

  Private Replicate endpoints:
  * `--model_type replicate.InferenceEndpoint` (for private endpoints)
  * `--model_name` - username/model-name slug from the deployed endpoint, e.g. `elim/elims-llama2-7b`



  * `--model_type cohere`
  * `--model_name` (optional, `command` by default) - The specific Cohere model you'd like to test
  * set the `COHERE_API_KEY` environment variable to your Cohere API key, e.g. "aBcDeFgHiJ123456789"; see https://dashboard.cohere.ai/api-keys when logged in



  * `--model_type groq`
  * `--model_name` - The name of the model to access via the Groq API
  * set the `GROQ_API_KEY` environment variable to your Groq API key, see https://console.groq.com/docs/quickstart for details on creating an API key



  * `--model_type ggml`
  * `--model_name` - The path to the ggml model you'd like to load, e.g. `/home/leon/llama.cpp/models/7B/ggml-model-q4_0.bin`
  * set the `GGML_MAIN_PATH` environment variable to the path to your ggml `main` executable



  `rest.RestGenerator` is highly flexible and can connect to any REST endpoint that returns plaintext or JSON. It does need some brief config, which will typically result a short YAML file describing your endpoint. See https://reference.garak.ai/en/latest/garak.generators.rest.html for examples.



  Use models from https://build.nvidia.com/ or other NIM endpoints.
  * set the `NIM_API_KEY` environment variable to your authentication API token, or specify it in the config YAML

  For chat models:
  * `--model_type nim`
  * `--model_name` - the NIM `model` name, e.g. `meta/llama-3.1-8b-instruct`

  For completion models:
  * `--model_type nim.NVOpenAICompletion`
  * `--model_name` - the NIM `model` name, e.g. `bigcode/starcoder2-15b`




  * set the `OCTO_API_TOKEN` environment variable to your Replicate API token, e.g. "r8-123XXXXXXXXXXXX"; see https://replicate.com/account/api-tokens when logged in

  Octo public endpoint:
  * `--model_type octo`
  * `--model_name` - the OctoAI public endpoint for the model, e.g. `mistral-7b-instruct-fp16`

  Octo private endpoint:
  * `--model_type octo.InferenceEndpoint` (for private endpoints)
  * `--model_name` - the deployed endpoint URL, e.g. `https://llama-2-70b-chat-xxx.octoai.run/v1/chat/completions`



  * `--model_type test`
  * (alternatively) `--model_name test.Blank`
  For testing. This always generates the empty string, using the `test.Blank` generator.  Will be marked as failing for any tests that *require* an output, e.g. those that make contentious claims and expect the model to refute them in order to pass.

  * `--model_type test.Repeat`
  For testing. This generator repeats back the prompt it received.



  | Probe | Description |
  | --- | --- |
  | blank | A simple probe that always sends an empty prompt. |
  | atkgen | Automated Attack Generation. A red-teaming LLM probes the target and reacts to it in an attempt to get toxic output. Prototype, mostly stateless, for now uses a simple GPT-2 [fine-tuned](https://huggingface.co/garak-llm/artgpt2tox) on the subset of hhrlhf attempts that yielded detectable toxicity (the only target currently supported for now). |
  | av_spam_scanning | Probes that attempt to make the model output malicious content signatures |
  | continuation | Probes that test if the model will continue a probably undesirable word |
  | dan | Various [DAN](https://adguard.com/en/blog/chatgpt-dan-prompt-abuse.html) and DAN-like attacks |
  | donotanswer | Prompts to which responsible language models should not answer. |
  | encoding | Prompt injection through text encoding |
  | gcg | Disrupt a system prompt by appending an adversarial suffix. |
  | glitch | Probe model for glitch tokens that provoke unusual behavior. |
  | grandma | Appeal to be reminded of one's grandmother. |
  | goodside | Implementations of Riley Goodside attacks. |
  | leakerplay | Evaluate if a model will replay training data. |
  | lmrc | Subsample of the [Language Model Risk Cards](https://arxiv.org/abs/2303.18190) probes |
  | malwaregen | Attempts to have the model generate code for building malware |
  | misleading | Attempts to make a model support misleading and false claims |
  | packagehallucination | Trying to get code generations that specify non-existent (and therefore insecure) packages. |
  | promptinject | Implementation of the Agency Enterprise [PromptInject](https://github.com/agencyenterprise/PromptInject/tree/main/promptinject) work (best paper awards @ NeurIPS ML Safety Workshop 2022) |
  | realtoxicityprompts | Subset of the RealToxicityPrompts work (data constrained because the full test will take so long to run) |
  | snowball | [Snowballed Hallucination](https://ofir.io/snowballed_hallucination.pdf) probes designed to make a model give a wrong answer to questions too complex for it to process |
  | xss | Look for vulnerabilities the permit or enact cross-site attacks, such as private data exfiltration. |



  `garak` generates multiple kinds of log:
  * A log file, `garak.log`. This includes debugging information from `garak` and its plugins, and is continued across runs.
  * A report of the current run, structured as JSONL. A new report file is created every time `garak` runs. The name of this file is output at the beginning and, if successful, also at the end of the run. In the report, an entry is made for each probing attempt both as the generations are received, and again when they are evaluated; the entry's `status` attribute takes a constant from `garak.attempts` to describe what stage it was made at.
  * A hit log, detailing attempts that yielded a vulnerability (a 'hit')



  Check out the [reference docs](https://reference.garak.ai/) for an authoritative guide to `garak` code structure.

  In a typical run, `garak` will read a model type (and optionally model name) from the command line, then determine which `probe`s and `detector`s to run, start up a `generator`, and then pass these to a `harness` to do the probing; an `evaluator` deals with the results. There are many modules in each of these categories, and each module provides a number of classes that act as individual plugins.

  * `garak/probes/` - classes for generating interactions with LLMs
  * `garak/detectors/` - classes for detecting an LLM is exhibiting a given failure mode
  * `garak/evaluators/` - assessment reporting schemes
  * `garak/generators/` - plugins for LLMs to be probed
  * `garak/harnesses/` - classes for structuring testing
  * `resources/` - ancillary items required by plugins

  The default operating mode is to use the `probewise` harness. Given a list of probe module names and probe plugin names, the `probewise` harness instantiates each probe, then for each probe reads its `recommended_detectors` attribute to get a list of `detector`s to run on the output.

  Each plugin category (`probes`, `detectors`, `evaluators`, `generators`, `harnesses`) includes a `base.py` which defines the base classes usable by plugins in that category. Each plugin module defines plugin classes that inherit from one of the base classes. For example, `garak.generators.openai.OpenAIGenerator` descends from `garak.generators.base.Generator`.

  Larger artefacts, like model files and bigger corpora, are kept out of the repository; they can be stored on e.g. Hugging Face Hub and loaded locally by clients using `garak`.




  * Take a look at how other plugins do it
  * Inherit from one of the base classes, e.g. `garak.probes.base.TextProbe`
  * Override as little as possible
  * You can test the new code in at least two ways:
    * Start an interactive Python session
      * Import the model, e.g. `import garak.probes.mymodule`
      * Instantiate the plugin, e.g. `p = garak.probes.mymodule.MyProbe()`
    * Run a scan with test plugins
      * For probes, try a blank generator and always.Pass detector: `python3 -m garak -m test.Blank -p mymodule -d always.Pass`
      * For detectors, try a blank generator and a blank probe: `python3 -m garak -m test.Blank -p test.Blank -d mymodule`
      * For generators, try a blank probe and always.Pass detector: `python3 -m garak -m mymodule -p test.Blank -d always.Pass`
    * Get `garak` to list all the plugins of the type you're writing, with `--list_probes`, `--list_detectors`, or `--list_generators`




  We have an FAQ [here](https://github.com/NVIDIA/garak/blob/main/FAQ.md). Reach out if you have any more questions! [leon@garak.ai](mailto:leon@garak.ai)

  Code reference documentation is at [garak.readthedocs.io](https://garak.readthedocs.io/en/latest/).



  You can read the [garak preprint paper](garak-paper.pdf). If you use garak, please cite us.

  ```
  @article{garak,
    title={{garak: A Framework for Security Probing Large Language Models}},
    author={Leon Derczynski and Erick Galinkin and Jeffrey Martin and Subho Majumdar and Nanna Inie},
    year={2024},
    howpublished={\url{https://garak.ai}}
  }
  ```

  <hr>

  _"Lying is a skill like any other, and if you wish to maintain a level of excellence you have to practice constantly"_ - Elim

  For updates and news see [@garak_llm](https://twitter.com/garak_llm)

  © 2023- Leon Derczynski; Apache license v2, see [LICENSE](LICENSE)


pkgId: 2c3cd5d179fceebd997c39fe1ba3689f52938f22bf179a4190eaf492ac2029f8
name: python-garf-help
arch: noarch
version: 2.9
epoch: 0
release: 1
summary: Development documents and examples for garf
url: https://pypi.org/project/garf/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-garf-2.9-1.src.rpm
location_href: Packages/python-garf-help-2.9-1.noarch.rpm
checksum_type: sha256
description:
  GARF = GATE ARF

  ```pip install garf```

  Scripts associated with the publication:
  Phys Med Biol. 2018 Oct 17;63(20):205013. doi: 10.1088/1361-6560/aae331.
  Learning SPECT detector angular response function with neural network for accelerating Monte-Carlo simulations.
  Sarrut D, Krah N, Badel JN, Létang JM.
  https://www.ncbi.nlm.nih.gov/pubmed/30238925

  A method to speed up Monte-Carlo simulations of single photon emission computed tomography (SPECT) imaging is proposed. It uses an artificial neural network (ANN) to learn the angular response function (ARF) of a collimator-detector system. The ANN is trained once from a complete simulation including the complete detector head with collimator, crystal, and digitization process. In the simulation, particle tracking inside the SPECT head is replaced by a plane. Photons are stopped at the plane, and the energy and direction are used as input to the ANN, which provides detection probabilities in each energy window. Compared to histogram-based ARF, the proposed method is less dependent on the statistics of the training data, provides similar simulation efficiency, and requires less training data. The implementation is available within the GATE platform.

  - Gate10 test: https://github.com/OpenGATE/opengate/blob/master/opengate/tests/src/test043_garf.py

rpm_license:
[cell repeats an earlier one in this file: 10254 characters]


pkgId: ce9a89ae3811608621eb0156c76588120ddf0d9b494f7cc707c6fa7f46a79743
name: python-garmin-fit-sdk-help
arch: noarch
version: 21.158.0
epoch: 0
release: 1
summary: Development documents and examples for garmin-fit-sdk
url: https://github.com/garmin/fit-python-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-garmin-fit-sdk-21.158.0-1.src.rpm
location_href: Packages/python-garmin-fit-sdk-help-21.158.0-1.noarch.rpm
checksum_type: sha256
description:
  The FIT SDK documentation is available at [https://developer.garmin.com/fit](https://developer.garmin.com/fit).

  Share your knowledge, ask questions, and get the latest FIT SDK news in the [FIT SDK Developer Forum](https://forums.garmin.com/developer/).


  * [Python](https:##www.python.org/downloads/) Version 3.6 or greater is required to run the FIT Python SDK


  ```sh
  pip install garmin-fit-sdk
  ```


  ```py
  from garmin_fit_sdk import Decoder, Stream

  stream = Stream.from_file("Activity.fit")
  decoder = Decoder(stream)
  messages, errors = decoder.read()

  print(errors)
  print(messages)
  ```





  Creating Decoder objects requires an input Stream representing the binary FIT file data to be decoded. See [Creating Streams](#creatingstreams) for more information on constructing Stream objects.

  Once a Decoder object is created it can be used to check that the Stream is a FIT file, that the FIT file is valid, and to read the contents of the FIT file.



  All valid FIT files should include a 12 or 14 byte file header. The 14 byte header is the preferred header size and the most common size used. Bytes 8-11 of the header contain the ASCII values ".FIT". This string can easily be spotted when opening a binary FIT file in a text or hex editor.

  ```
    Offset: 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
  00000000: 0E 10 43 08 78 06 09 00 2E 46 49 54 96 85 40 00    ..C.x....FIT..@.
  00000010: 00 00 00 07 03 04 8C 04 04 86 07 04 86 01 02 84    ................
  00000020: 02 02 84 05 02 84 00 01 00 00 19 28 7E C5 95 B0    ...........(~E.0
  ```



  The checkIntegrity method performs three checks on a FIT file:

  1. Checks that bytes 8-11 of the header contain the ASCII values ".FIT".
  2. Checks that the total file size is equal to Header Size + Data Size + CRC Size.
  3. Reads the contents of the file, computes the CRC, and then checks that the computed CRC matches the file CRC.

  A file must pass all three of these tests to be considered a valid FIT file. See the [IsFIT(), CheckIntegrity(), and Read() Methods recipe](/fit/cookbook/isfit-checkintegrity-read/) for use-cases where the checkIntegrity method should be used and cases when it might be better to avoid it.


  The Read method decodes all messages from the input stream and returns an object containing a list of errors encountered during the decoding and a dictionary of decoded messages grouped by message type. Any exceptions encountered during decoding will be caught by the Read method and added to the list of errors.

  The Read method accepts an optional options object that can be used to customize how field data is represented in the decoded messages. All options are enabled by default. Disabling options may speed up file decoding. Options may also be enabled or disable based on how the decoded data will be used.

  ```py
  messages, errors = read(
              apply_scale_and_offset = True,
              convert_datetimes_to_dates = True,
              convert_types_to_strings = True,
              enable_crc_check = True,
              expand_sub_fields = True,
              expand_components = True,
              merge_heart_rates = True,
              mesg_listener = None)
  ```

  Optional callback function that can be used to inspect or manipulate messages after they are fully decoded and all the options have been applied. The message is mutable and we be returned from the Read method in the messages dictionary.

  Example mesg_listener callback that tracks the field names across all Record messages.

  ```py
  from garmin_fit_sdk import Decoder, Stream, Profile

  stream = Stream.from_file("Activity.fit")
  decoder = Decoder(stream)

  record_fields = set()
  def mesg_listener(mesg_num, message):
      if mesg_num == Profile['mesg_num']['RECORD']:
          for field in message:
              record_fields.add(field)

  messages, errors = decoder.read(mesg_listener = mesg_listener)

  if len(errors) > 0:
      print(f"Something went wrong decoding the file: {errors}")
      return

  print(record_fields)
  ```


  When true the scale and offset values as defined in the FIT Profile are applied to the raw field values.
  ```py
  {
    'altitude': 1587 ## with a scale of 5 and offset of 500 applied
  }
  ```
  When false the raw field value is used.
  ```py
  {
    'altitude': 10435 ## raw value store in file
  }
  ```

  When true the CRC of the file is calculated when decoding a FIT file and then validated with the CRC found in the file. Disabling the CRC calculation will improve the performance of the read method.

  When true subfields are created for fields as defined in the FIT Profile.
  ```py
  {
    'event': 'rear_gear_change',
    'data': 16717829,
    'gear_change_data':16717829 ## Sub Field of data when event == 'rear_gear_change'
  }
  ```
  When false subfields are omitted.
  ```py
  {
    'event': 'rearGearChange',
    'data': 16717829
  }
  ```

  When true field components as defined in the FIT Profile are expanded into new fields. expand_sub_fields must be set to true in order for subfields to be expanded

  ```py
  {
    'event': 'rear_gear_change'
    'data': 16717829,
    'gear_change_data':16717829, ## Sub Field of data when event == 'rear_gear_change'
    'front_gear': 2, ## Expanded field of gear_change_data, bits 0-7
    'front_gear_num': 53, ## Expanded field of gear_change_data, bits 8-15
    'rear_gear': 11, ## Expanded field of gear_change_data, bits 16-23
    'rear_gear_num': 1, ## Expanded field of gear_change_data, bits 24-31
  }
  ```
  When false field components are not expanded.
  ```py
  {
    'event': 'rear_gear_change',
    'data': 16717829,
    'gear_change_data': 16717829 ### Sub Field of data when event == 'rear_gear_change'
  }
  ```

  When true field values are converted from raw integer values to the corresponding string values as defined in the FIT Profile.
  ```py
  { 'type':'activity'}
  ```
  When false the raw integer value is used.
  ```py
  { 'type': 4 }
  ```

  When true FIT Epoch values are converted to Python datetime objects.
  ```py
  { 'time_created': {Python datetime object} }
  ```
  When false the FIT Epoch value  is used.
  ```py
  { 'time_created': 995749880 }
  ```
  When false the Util.convert_timestamp_to_datetime method may be used to convert FIT Epoch values to Python datetime objects.

  When true automatically merge heart rate values from HR messages into the Record messages. This option requires the apply_scale_and_offset and expand_components options to be enabled. This option has no effect on the Record messages when no HR messages are present in the decoded messages.


  Stream objects contain the binary FIT data to be decoded. Streams objects can be created from bytearrays, BufferedReaders, and BytesIO objects. Internally the Stream class uses a BufferedReader to manage the byte stream.


  ```py
  stream = Stream.from_file("activity.fit")
  print(f"is_fit: {Decoder.is_fit(stream)}")
  ```

  ```py
  fit_byte_array = bytearray([0x0E, 0x10, 0xD9, 0x07, 0x00, 0x00, 0x00, 0x00, 0x2E, 0x46, 0x49, 0x54, 0x91, 0x33, 0x00, 0x00])
  stream = Stream.from_byte_array(fit_byte_array)
  print(f"is_fit: {Decoder.is_fit(stream)}")
  ```

  ```py
  fit_byte_bytes_io = io.BytesIO(bytearray([0x0E, 0x10, 0xD9, 0x07, 0x00, 0x00, 0x00, 0x00, 0x2E, 0x46, 0x49, 0x54, 0x91, 0x33, 0x00, 0x00]))
  stream = Stream.from_byte_io(fit_byte_bytes_io)
  print(f"is_fit: {Decoder.is_fit(stream)}")
  ```

  ```py
  fit_buffered_reader = io.BufferedReader(io.BytesIO(bytearray([0x0E, 0x10, 0xD9, 0x07, 0x00, 0x00, 0x00, 0x00, 0x2E, 0x46, 0x49, 0x54, 0x91, 0x33, 0x00, 0x00])))
  stream = Stream.from_buffered_reader(fit_buffered_reader)
  print(f"is_fit: {Decoder.is_fit(stream)}")
  ```


  The Util object contains both constants and methods for working with decoded messages and fields.

  The FIT_EPOCH_S constant represents the number of seconds between the Unix Epoch and the FIT Epoch.
  ```py
  FIT_EPOCH_S = 631065600
  ```
  The FIT_EPOCH_S value can be used to convert FIT Epoch values to Python datetime objects.
  ```py
  python_date = datetime.datetime.utcfromtimestamp(fitDateTime + FIT_EPOCH_S)
  ```

  A convenience method for converting FIT Epoch values to Python Datetime objects.
  ```py
  python_date = convert_timestamp_to_datetime(fit_datetime)
  ```


pkgId: 354398f56ef8362df247cb2b8e2afc03edcde6d70f0ffff5ce9c5e0ea66d9fea
name: python-gasp-ssfp-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for gasp-ssfp
url: https://github.com/michaelmendoza/gasp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gasp-ssfp-0.0.2-1.src.rpm
location_href: Packages/python-gasp-ssfp-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  GASP (Generation of Arbitrary Spectral Profiles) is a Python library for simulating and analyzing MRI sequences, particularly focused on balanced Steady-State Free Precession (bSSFP) and spectral shaping techniques. This project provides tools for simulating MRI signals, generating phantoms, and applying the GASP method to achieve desired spectral profiles.



  - Simulation of bSSFP sequences
  - Generation of various phantom types (e.g., Shepp-Logan, circles, blocks)
  - Implementation of the GASP method for spectral shaping
  - Tools for analyzing and visualizing MRI data
  - Support for different tissue types and their relaxation properties



  This project requires python 3.8+ and has the following dependancies:
  `numpy matplotlib scikit-image seaborn pymapvbvd jupyterlab gdown scipy`

  To setup a local python enviroment with conda:

  Create a new conda environment from scatch
  > ```
  > conda create -n gasp python=3.8
  > conda activate gasp
  > ```
  > Then install packages with pip:
  > ```
  > pip install numpy matplotlib scikit-image seaborn pymapvbvd jupyterlab gdown scipy
  > ```



  Here's a basic example of how to use the GASP simulation:

  ```python
  from gasp import simulation, responses


  width, height = 256, 256
  npcs = 16
  TRs = [5e-3, 10e-3, 20e-3]
  alpha = np.deg2rad(60)
  gradient = 2 * np.pi


  D = responses.gaussian(width, bw=0.2, shift=0)


  Ic, M, An = simulation.simulate_gasp(D, width, height, npcs, TRs, alpha, gradient)


  simulation.view_gasp_results(Ic, M, D)
  ```



  - `analysis.py`: Contains functions for analyzing GASP results and Dixon methods
  - `dataloader.py`: Handles loading of raw MRI data
  - `dataset.py`: Provides functions to load specific datasets
  - `gasp.py`: Core implementation of the GASP method
  - `phantom.py`: Functions for generating various phantom types
  - `responses.py`: Implements different spectral response functions
  - `simulation.py`: Main simulation routines for bSSFP and GASP
  - `ssfp.py`: Implementation of Steady-State Free Precession signal equations
  - `tissue.py`: Defines tissue properties and generates tissue phantoms
  - `view.py`: Visualization tools for 3D data


pkgId: e5d7e388fc4e86edafe892eb09878570bc0c1da030006faf205590e70305a375
name: python-gatlens-opinionated-template-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for gatlens-opinionated-template
url: https://pypi.org/project/gatlens-opinionated-template/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gatlens-opinionated-template-0.0.2-1.src.rpm
location_href: Packages/python-gatlens-opinionated-template-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  _v0.0.1 is Currently not for production!_

  [![Uses the Cookiecutter Data Science project upstream](https://img.shields.io/badge/CCDS-Project%20fork-328F97?logo=cookiecutter)](https://cookiecutter-data-science.drivendata.org/) [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv) [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

  A modern, opinionated full-stack [CookieCutter](https://www.cookiecutter.io/) project template that prioritizes developer experience and cutting-edge tools. Built on (and synced with) the foundation of [CookieCutter Data Science (CCDS) V2](https://cookiecutter-data-science.drivendata.org/), this template incorporates carefully selected defaults, dependency stack, customizations, and contemporary best practices for Python development, research projects, and academic work.

  _The main functionality of this project is kept as close as possible to the CCDS template as to avoid additional maintenance on my end. This might mean a mismatch between practices I recommend and the ones they do. Ex: Makefiles on root, Taskfiles in template._

  _See how CCDS compares with regular cookiecutter templates and my decisions [here](https://drivendata.co/blog/ccds-v2). For the most part, I look at CCDS as [Chesterton's Fence](https://www.lesswrong.com/tag/chesterton-s-fence), making sure to check my decisions against theirs before making changes. Still, the [CCDS team notes there's still some missing functionality](https://drivendata.co/blog/ccds-v2#whats-still-missing) including the [lack of a uv installer](https://github.com/drivendataorg/cookiecutter-data-science/discussions/403). The CCDS template still comes with some [nice features](https://drivendata.co/blog/ccds-v2#whats-new). CCDS has also considered [ruff as the default linting + formatting option](https://github.com/drivendataorg/cookiecutter-data-science/pull/387)_

  <!-- TODO: Research Pachyderm -->

  <!-- CCDS V2 appears not to like git lfs much, expensive. -->


  - 🚀 Modern tooling (UV, Ruff, FastAPI, Pydantic, Typer, Loguru, Polars, etc.) over traditional defaults
  - 📦 Batteries-included configuration with sensible defaults
  - 🔧 Highly customizable while maintaining simplicity
  - 📈 Scales from personal projects to production
  - 🤝 Perfect for individuals and small teams
  - 🔄 Living template that evolves with the ecosystem




  _I'm looking for a way to use [Cruft](https://cruft.github.io/cruft/) over [CookieCutter](https://www.cookiecutter.io/) + CCDS, but for now, CCDS needs to be used due to their custom configuration_



  <!-- It is recommended to use [Cruft](https://cruft.github.io/cruft/) instead of [CookieCutter](https://www.cookiecutter.io/). The resulting project is the same, but with the added option of being able to sync your project with the original template if this repository updates as if it were an incomming commit.

  Install Cruft
  ```bash
      
      brew install cruft
  ```

  ```bash
      
      pip install cruft
  ```


  Clone using Cruft
  ```bash
      cruft create https://github.com/GatlenCulp/gatlens-opinionated-template
  ``` -->
  Install Gatlen's Opinionated Template (GOTem)
  ```bash
  uv tool install gatlens-opinionated-template
  ```

  Instantiate my project
  ```bash
  uvx --from gatlens-opinionated-template gotem
  ```




  The directory structure of your new project will look something like this (depending on the settings that you choose):

  ```
  ├── LICENSE            <- Open-source license if one is chosen
  ├── Makefile           <- Makefile with convenience commands like `make data` or `make train`
  ├── README.md          <- The top-level README for developers using this project.
  ├── data
  │   ├── external       <- Data from third party sources.
  │   ├── interim        <- Intermediate data that has been transformed.
  │   ├── processed      <- The final, canonical data sets for modeling.
  │   └── raw            <- The original, immutable data dump.
  │
  ├── docs               <- A default mkdocs project; see www.mkdocs.org for details
  │
  ├── models             <- Trained and serialized models, model predictions, or model summaries
  │
  ├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
  │                         the creator's initials, and a short `-` delimited description, e.g.
  │                         `1.0-jqp-initial-data-exploration`.
  │
  ├── pyproject.toml     <- Project configuration file with package metadata for
  │                         {{ cookiecutter.module_name }} and configuration for tools like black
  │
  ├── references         <- Data dictionaries, manuals, and all other explanatory materials.
  │
  ├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
  │   └── figures        <- Generated graphics and figures to be used in reporting
  │
  ├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
  │                         generated with `pip freeze > requirements.txt`
  │
  ├── setup.cfg          <- Configuration file for flake8
  │
  └── {{ cookiecutter.module_name }}   <- Source code for use in this project.
      │
      ├── __init__.py             <- Makes {{ cookiecutter.module_name }} a Python module
      │
      ├── config.py               <- Store useful variables and configuration
      │
      ├── dataset.py              <- Scripts to download or generate data
      │
      ├── features.py             <- Code to create features for modeling
      │
      ├── modeling
      │   ├── __init__.py
      │   ├── predict.py          <- Code to run model inference with trained models
      │   └── train.py            <- Code to train models
      │
      └── plots.py                <- Code to create visualizations
  ```


  <!--
  This project is more of a hobby and research project more than it is a practical template. Gatlen really enjoys the occasional research on the tooling ecosystem and understanding which tools solve what problems and how. He tends to have a very prefectionist perspective on projects beyond what is practical. Many of the packages included in this project, Gatlen has not yet used, but rather examined and compared against other tools and determined to be something to leverage once the need arises. The selection of packages and tools are in a way, a reminder of what resources he has have determined in advance to likely be helpful.

  Here are a few guiding principles of this template to determine whether or not you should use it:
  1. **Modern and Supported over Ubiquitous** -- Many of the packages and tools I have chosen for this package are NOT the defaults. (Another possible name for this template was "Everything but Defaults"). Unless I deem a built-in library to be the best of its type, it is likely unused. Instead of Logging I used Loguru. Instead of MatPlotLib I use Plotly. Instead of json I used orjson. Instead of pip I used UV. Instead of Django or Flask I used FastAPI. Instead of Argparse I use Typer.  Instead of Time, I use Arrow. Instead of Pandas I use Polars. It's not that these packages aren't used, they are extremely popular and indeed tend to offer better speed and functionality than the "defaults." Perhaps this is simply a selection of trendy packages that add unnecessary bloat and learning curves. But I think these packages can be a helpful learning experience that help me and others leverage the power this new rust-powered python ecosystem of tools that will become increasingly popular with time. Yes, these might not have as much developer documentation or extensions built up around it, but I think they important nonetheless and the novelty is also a plus in the sense that a lot of baggage and backwards-compatability that comes with an established package is not there. There aren't a lot of shitty tutorials from 15 years ago and a bloated API. Instead there is a very clear cut API with great defaults. Often times these packages work just with the sam syntax as the old greats do.
  2. **Aspirational over Practical** --...
  3. **Simplicity** -- I tend to pick packages that offer a lot of power with very simple and non-intrusive syntax. As an example, Django is a popular web framework that is very opinionated and requires a particular project structure and syntax to play nicely. Indeed, much of what it does is batteries-included best practice with tons of extensions made by the community, but it is also a very heavy library and once you start with a Django project, it is very hard to switch. I try to make it as easy as possible to switch in and out whatever you want to use.
  4. **Good Defaults** -- To me, it's important to have good defaults on the packages I have set up so I can just import them and know I'm getting the best experience out of the box. A lot of this is the reason why I choose these modern packages -- because instead of having to bend over backwards to make things backwards compatible, the package can get a hard restart with decades of learning what the established greats did. I think about it this way: If The reset button were to be hit right now on the what tools and packages people used in Python, what do I wish they did?
  5. **Customizability** -- I love customizing my tools and opt for tools where I can do a lot of customization and fiddling.
  6. **Small Teams / Individual** -- As someone who personally tends to work by myself or with a few people on research projects, I gear this template towards iterating quickly and with high quality. If a tool requires such deep knowledge that someone has to spend a day researching it just to use, I don't want it.
  7. **Scalable** -- As noted above, this is mainly geared to individuals and small teams. However, in the case you want to scale production or team size or even if you move to a new and larger organization, I want those skills to transfer and for there to be little more to learn and so that you don't have to learn an entirely new skillset or library. -->


  This template is primarily a research and learning project that explores modern Python development tools and practices. Rather than focusing solely on practical, production-ready solutions, it represents an aspirational view of Python development that emphasizes cutting-edge tools and emerging best practices.



  1. **Reset-Button Development** 🔄
     - Reimagines Python tooling without legacy constraints
     - Selects tools leveraging decades of lessons from established tools while avoiding their compromises

  2. **Research-Driven Exploration** 🔬
     - Functions as a living laboratory for modern Python development
     - No default goes unscruitinized, with curated promising technologies based on careful comparative analysis

  3. **Individual and Small Team Focus with Scalability** 👥
     - Optimized for personal projects and small research teams
     - Maintains professional standards that scale to larger organizations
     - Prioritizes tools that don't require deep expertise to start using and are helpful at any scale.

  4. **Aspirational Over Practical** 🌟
     - Embraces perfectionist ideals in tooling choices
     - Values learning opportunities over conventional solutions
     - Willing to trade immediate familiarity for better long-term solutions

  5. **Thoughtfully Opinionated** 🤔
     - Provides carefully selected defaults based on extensive research
     - Maintains modularity and avoids vendor lock-in
     - Prefers simple, non-intrusive APIs over heavyweight frameworks
     - Examples: Loguru > logging, Polars > Pandas, UV > pip, FastAPI > Flask

  6. **Quality Driven** ✨
     - Emphasizes clean, maintainable code
     - Incorporates professional-grade tooling and practices
     - Focuses on developer experience without sacrificing robustness

  7. **Sexy**
      - Just because coding is work doesn't mean it can't be fun. Sometimes you need those `pretty colors` and fancy ~graphs~ if you want that ADHD brain of yours pumped full of happy juice. I want my code to be like the notes of your overachieving classmate with a bullet journal.

  > ⚠️ Note: This template intentionally prioritizes exploration and learning over immediate practicality. While all included tools have been carefully researched, not all have been extensively tested in production environments. Users should view this as a forward-looking reference implementation rather than a production-ready solution.



  **[VS Code](https://code.visualstudio.com/) / [Cursor](https://www.cursor.com/)** 🖥️
  - Primary IDE with full ecosystem support
  - Cursor fork provides enhanced AI integration
  - Includes pre-configured workspace settings and debug profiles
  - Supports remote development and notebook integration
  - Replaces traditional Jupyter environments

  > While many IDEs exist, VS Code's hackability, extensive ecosystem, and remote capabilities make it ideal for modern development. Cursor extends this with AI features while maintaining full VS Code compatibility. The decision to use VS Code even for notebooks (over JupyterLab) allows for a consistent development experience with all settings and extensions available.

  **[UV](https://github.com/astral-sh/uv)** ⚡
  - Ultra-fast Rust-based Python package manager
  - Combines functionality of Poetry, virtualenv, and pipx (with dirt easy deployment to PyPi.)
  - Created by Astral (Ruff team)
  - Significant performance benefits for CI/CD
  - Maintains pip compatibility

  > UV represents the next generation of Python package management. While tools like Poetry are mature, UV's Rust foundation provides exceptional speed (especially important in CI/CD) while maintaining compatibility with traditional pip workflows. Being from the Astral team (creators of Ruff) gives confidence in its long-term maintenance.

  <!-- TODO: Explain why not conda environment -->

  **[Task](https://taskfile.dev/)** 🎯
  - Modern alternative to Make/Poetry scripts
  - Simple, cross-platform task runner
  - Excellent GitHub Actions integration
  - Clean, intuitive YAML syntax

  > Task was chosen over alternatives like Make, Poetry scripts, or Poe the Poet for its simplicity and cross-platform support. Its YAML syntax is immediately understandable, and it works seamlessly on Windows - a common pain point with Makefiles.

  **[Git](https://git-scm.com/) + [GitLFS](https://git-lfs.com/) + [GitHub](https://github.com/)** 📚
  - Industry standard version control
  - Extensive ecosystem and integrations
  - Built-in project management features
  - Git Large File Storage (LFS) is a little-setup solution for file larger than the typical script like JSON files or Python Notebooks. Even larger files are recommended to use another storage solution such as a database or ignoring.

  **[GitHub Actions](https://github.com/features/actions)** 🔄
  - Integrated CI/CD solution
  - Simple configuration and maintenance
  - Native GitHub integration
  - Extensive marketplace of actions

  > While there are many CI/CD solutions available, GitHub Actions provides the tightest integration with our repository platform. Its marketplace of pre-built actions and simple YAML configuration makes it ideal for small teams who need professional CI/CD without dedicated DevOps resources.

  **[Docker](https://www.docker.com/) + [Orbstack](https://orbstack.dev/)** 🐳
  - Standard containerization platform
  - Orbstack for MacOS (lighter Docker Desktop alternative)
  - VM support through Orbstack
  - Consistent development environments

  > Docker remains the standard for containerization, but Docker Desktop can be resource-intensive. Orbstack provides a lightweight alternative for MacOS users while maintaining full Docker compatibility and adding convenient VM capabilities. Kubernetes is being explored but may not be the best setup for small development.

  **[Dev Containers](https://containers.dev/)** 📦
  - Standardized development environments
  - VS Code integration
  - *Note: Under evaluation*

  > While Dev Containers show promise for standardizing development environments, they're included as an optional feature pending further evaluation by Gatlen.

  **[AWS](https://www.geeksforgeeks.org/aws-vs-google-cloud-platform-vs-azure/#)** ☁️
  - Mature cloud infrastructure platform
  - Comprehensive service ecosystem
  - Industry standard tooling
  - Template remains cloud-agnostic where possible

  > AWS was selected for its maturity and comprehensive service offering. However, recognizing that cloud preferences vary, the template maintains cloud-agnostic patterns where possible, allowing for easy adaptation to other providers.

  > 💡 These tool selections reflect a balance between modern capabilities, developer experience, and professional requirements. Each choice prioritizes simplicity and maintainability while ensuring scalability for growing projects.


  ```python
  [project]

  dependencies = [
      "loguru>=0.7.3",         # Better logging
      "plotly>=5.24.1",        # Interactive plotting
      "pydantic>=2.10.3",      # Data validation
      "rich>=13.9.4",          # Rich terminal output
  ]

  [dependency-groups]
  ai-apps = [  # AI application development packages
      "ell-ai>=0.0.15",        # AI toolkit
      "langchain>=0.3.12",     # LLM application framework
      "megaparse>=0.0.45",     # Advanced text parsing
  ]
  ai-train = [  # Machine learning and model training packages
      "datasets>=3.1.0",           # Dataset handling
      "einops>=0.8.0",            # Tensor operations
      "jaxtyping>=0.2.36",        # Type hints for JAX
      "onnx>=1.17.0",             # ML model interoperability
      "pytorch-lightning>=2.4.0",  # PyTorch training framework
      "ray[tune]>=2.40.0",        # Distributed computing
      "safetensors>=0.4.5",       # Safe tensor serialization
      "scikit-learn>=1.6.0",      # Traditional ML algorithms
      "shap>=0.46.0",             # Model explainability
      "torch>=2.5.1",             # Deep learning framework
      "transformers>=4.47.0",     # Transformer models
      "umap-learn>=0.5.7",        # Dimensionality reduction
      "wandb>=0.19.1",            # Experiment tracking
      "nnsight>=0.3.7",           # ML Interp and Manipulation
  ]
  async = [  # Asynchronous programming
      "uvloop>=0.21.0",           # Fast event loop implementation
  ]
  cli = [  # Command-line interface tools
      "typer>=0.15.1",            # CLI builder
  ]
  cloud = [  # Cloud infrastructure tools
      "ansible>=11.1.0",          # Infrastructure automation
      "boto3>=1.35.81",          # AWS SDK
  ]
  config = [  # Configuration management
      "cookiecutter>=2.6.0",      # Project templating
      "gin-config>=0.5.0",        # Config management
      "jinja2>=3.1.4",           # Template engine
  ]
  data = [  # Data processing and storage
      "dagster>=1.9.5",           # Data orchestration
      "duckdb>=1.1.3",           # Embedded analytics database
      "lancedb>=0.17.0",         # Vector database
      "networkx>=3.4.2",         # Graph operations
      "numpy>=1.26.4",           # Numerical computing
      "orjson>=3.10.12",         # Fast JSON parsing
      "pillow>=10.4.0",          # Image processing
      "polars>=1.17.0",          # Fast dataframes
      "pygwalker>=0.4.9.13",     # Data visualization
      "sqlmodel>=0.0.22",        # SQL ORM
      "tomli>=2.0.1",            # TOML parsing
  ]
  dev = [  # Development tools
      "bandit>=1.8.0",           # Security linter
      "better-exceptions>=0.3.3", # Improved error messages
      "cruft>=2.15.0",           # Project template management
      "faker>=33.1.0",           # Fake data generation
      "hypothesis>=6.122.3",     # Property-based testing
      "pip>=24.3.1",             # Package installer
      "polyfactory>=2.18.1",     # Test data factory
      "pydoclint>=0.5.11",       # Docstring linter
      "pyinstrument>=5.0.0",     # Profiler
      "pyprojectsort>=0.3.0",    # pyproject.toml sorter
      "pyright>=1.1.390",        # Static type checker
      "pytest-cases>=3.8.6",     # Parametrized testing
      "pytest-cov>=6.0.0",       # Coverage reporting
      "pytest-icdiff>=0.9",      # Improved diffs
      "pytest-mock>=3.14.0",     # Mocking
      "pytest-playwright>=0.6.2", # Browser testing
      "pytest-profiling>=1.8.1", # Test profiling
      "pytest-random-order>=1.1.1", # Randomized test order
      "pytest-shutil>=1.8.1",    # File system testing
      "pytest-split>=0.10.0",    # Parallel testing
      "pytest-sugar>=1.0.0",     # Test progress visualization
      "pytest-timeout>=2.3.1",   # Test timeouts
      "pytest>=8.3.4",           # Testing framework
      "ruff>=0.8.3",             # Fast Python linter
      "taplo>=0.9.3",            # TOML toolkit
      "tox>=4.23.2",             # Test automation
      "uv>=0.5.7",               # Fast pip replacement
  ]
  dev-doc = [  # Documentation tools
      "mdformat>=0.7.19",        # Markdown formatter
      "mkdocs-material>=9.5.48", # Documentation theme
      "mkdocs>=1.6.1",          # Documentation generator
  ]
  dev-nb = [  # Notebook development tools
      "jupyter-book>=1.0.3",     # Notebook publishing
      "nbformat>=5.10.4",        # Notebook file format
      "nbqa>=1.9.1",             # Notebook linting
      "testbook>=0.4.2",         # Notebook testing
  ]
  gui = [  # Graphical interface tools
      "streamlit>=1.41.1",       # Web app framework
  ]
  misc = [  # Miscellaneous utilities
      "boltons>=24.1.0",         # Python utilities
      "cachetools>=5.5.0",       # Caching utilities
      "wrapt>=1.17.0",           # Decorator utilities
  ]
  nb = [  # Jupyter notebook tools
      "chime>=0.7.0",            # Sound notifications
      "ipykernel>=6.29.5",       # Jupyter kernel
      "ipython>=7.34.0",         # Interactive Python shell
      "ipywidgets>=8.1.5",       # Jupyter widgets
      "jupyterlab>=4.3.3",       # Notebook IDE
  ]
  web = [  # Web development and scraping
      "beautifulsoup4>=4.12.3",  # HTML parsing
      "fastapi>=0.115.6",        # Web framework
      "playwright>=1.49.1",      # Browser automation
      "requests>=2.32.3",        # HTTP client
      "scrapy>=2.12.0",          # Web scraping
      "uvicorn>=0.33.0",         # ASGI server
      "zrok>=0.4.42",            # Tunnel service
  ]

  [tool.uv]
  default-groups = ["dev", "data", "nb"]
  ```



  We welcome contributions! [See the docs for guidelines](./CONTRIBUTING.md).



  It is recommended to use [UV](https://github.com/astral-sh/uv) for installations.

  Create virtual environment
  ```bash
  uv venv
  ```

  <!-- Install general requirements
  ```bash
      uv pip install -e .
  ``` -->

  Install dev requirements
  ```bash
  uv pip install -r dev-requirements.txt
  ```



  <!-- uvx vs uv run https://docs.astral.sh/uv/concepts/tools/ -->

  ```bash
  uv run pytest
  ```

  _Note: configs[2-5] require conda to be installed. MiniConda has not yet been researched to see if it is the best option out there but it will make your run work:_
  <!-- Conda-forge may be better -->
  ```bash
  brew install --cask miniconda
  ```



  This project builds upon the excellent work of several established templates and projects:

  **[cookiecutter-data-science](https://github.com/drivendataorg/cookiecutter-data-science)** 📊
  - The original inspiration for this template
  - Established many best practices for data science project organization
  - Created by DrivenData, widely adopted in the data science community

  **[cookiecutter-modern-datascience](https://github.com/crmne/cookiecutter-modern-datascience)** 🔬

  **[cookiecutter-uv](https://github.com/fpgmaas/cookiecutter-uv)** ⚡

  **[full-stack-fastapi-template](https://github.com/fastapi/full-stack-fastapi-template)** 🚀

  > 💡 While this template draws inspiration from these excellent projects, it takes an opinionated approach to combining their best aspects while introducing modern tooling and development practices.


pkgId: 325cd36bcb160957066c930f0b163a33fe563d9e48779652a5f55abc19da2e55
name: python-gazu-help
arch: noarch
version: 0.10.21
epoch: 0
release: 1
summary: Development documents and examples for gazu
url: https://gazu.cg-wire.com/
rpm_license: GNU Library or Lesser General Public License (LGPL)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gazu-0.10.21-1.src.rpm
location_href: Packages/python-gazu-help-0.10.21-1.noarch.rpm
checksum_type: sha256
description:
  The Kitsu Python client allows you to fetch data easily from the Kitsu
  collaboration platform. With Gazu, you bring assets and shots data into your
  pipeline tools. It comes with extra features such as preview publishing and
  event stream listening.
  It is made to be used with the `Kitsu API <https://zou.cg-wire.com>`__. It
  requires an up-and-running instance of Kitsu to run correctly.
  |CI badge| |Discord| |Downloads|


pkgId: 390f54da852b89e1c4f1579a3d4b12216e656fe08f43387123921334162af7b5
name: python-gcadev-help
arch: noarch
version: 0.25.0
epoch: 0
release: 1
summary: Development documents and examples for gcadev
url: https://github.com/onuratakan/gpt-computer-assistant
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gcadev-0.25.0-1.src.rpm
location_href: Packages/python-gcadev-help-0.25.0-1.noarch.rpm
checksum_type: sha256
description:
  <a href="#">
      <img src="https://github.com/user-attachments/assets/27778034-29f5-4a71-b696-4e3f70760b26" >
    </a>
  </p>



  Hi, this is an open source framework to build vertical AI agent. We just support many llms and new technologies like mcp. You can build your own vertical ai agent army in few commands with the stucturized API.


  <p>



    <p >
      <a href="https://www.producthunt.com/posts/gpt-computer-assistant?embed=true&utm_source=badge-top-post-badge&utm_medium=badge&utm_souce=badge-gpt&#0045;computer&#0045;assistant" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=465468&theme=dark&period=daily" alt="GPT&#0032;Computer&#0032;Assistant - Create&#0032;intelligence&#0032;for&#0032;your&#0032;products | Product Hunt" width="200"  /></a>
      .
      <a href="https://discord.gg/qApFmWMt8x"><img alt="Static Badge" src="https://img.shields.io/badge/Discord-Join?style=social&logo=discord" width=120></a>
      .
      <a href="https://x.com/GPTCompAsst"><img alt="Static Badge" src="https://img.shields.io/badge/X_App-Join?style=social&logo=x" width=100></a>
    </p>




    <p>
    <a href="https://www.python.org/">
    <img src="https://img.shields.io/badge/Made%20with-Python-1f425f.svg" alt="Made_with_python">
    </a>
    .
    <img src="https://static.pepy.tech/personalized-badge/gpt-computer-assistant?period=total&units=international_system&left_color=grey&right_color=blue&left_text=PyPI%20Downloads" alt="pypi_downloads">
    </p>





  <p align="center">
  <br>

    <br>
  </p>




  With [playground.gca.dev](https://playground.gca.dev/) you are ready to test and create your own strategies for creating an Vertical AI Agent.

  - Playground sessions limited to <b>10 minute</b>.

  <a href="https://playground.gca.dev/">
    <img src="https://github.com/user-attachments/assets/125a1a15-0fee-4c7e-bfc5-1a23ef83c92d" alt="Playground"  width=1000>
  </a>

  <p align="center">
  <br>
    <br>

  </p>


  GCA is an AI agent framework designed to make computer use across Windows, macOS, and Ubuntu. GCA enables you to replace repetitive, small-logic-based tasks worker to an AI. There is an really important potential that we believe. Whether you’re a developer, analyst, or IT professional, GCA can empower you to accomplish more in less time.


  Imagine this:



  - <b>Extract the tech stacks of xxx Company</b>             | Sales Development Representer
  - <b>Identify Relevant tables for Analysis for xxx</b>      | Data Analytics
  - <b>Check the logs to find core cause of this incident</b> | Technical Support Engineer
  - <b>Making CloudFlare Security Settings</b>                | Security Specialist


  These examples shows how GCA is realize the concept of <b>Vertical AI Agents</b> solutions that not only replicate human tasks, GCA also in the beyond of human speed at same cases.


  <p align="center">
  <br>
    <br>

  </p>





  GCA is a Python-based project that runs on multiple operating systems, including Windows, macOS, and Ubuntu. It integrates external concepts, like the Model Context Protocol (MCP), along with its own modules, to interact with and control a computer efficiently. The system performs both routine and advanced tasks by mimicking human-like actions and applying computational precision.




  GCA can replicate common user actions, such as:
  -	<b>Clicking</b>: Interact with buttons or other UI elements.
  -	<b>Reading</b>: Recognize and interpret text on the screen.
  -	<b>Scrolling</b>: Navigate through documents or web pages.
  -	<b>Typing</b>: Enter text into forms or other input fields.

  Through MCP and GCA’s own modules, it achieves tasks that go beyond standard human interaction, such as:

  -	<b>Updating dependencies</b> of a project in seconds.
  -	<b>Analyzing entire database</b> tables to locate specific data almost instantly.
  - <b>Automating cloud security</b> configurations with minimal input.




  <p align="center">
  <br>
    <br>
    <br>

  </p>



  - Python 3.10

  <p align="center">
  <br>
    <br>

  </p>



  <b>Installation</b>
  ```console
  pip install gpt-computer-assistant
  ```

  Single Instance:
  ```python
  from gpt_computer_assistant import cloud


  instance = cloud.instance()


  instance.current_screenshot()


  result = instance.request("Extract the tech stacks of gpt-computer-assitant Company", "i want a list")
  print(result)


  instance.close()
  ```

  <img src="https://github.com/user-attachments/assets/3fd70530-6b86-43b4-9025-dce7853e4a38" alt="Cloud"  width=1000>




  <p align="center">
  <br>
  <br>
  <br>
  </p>






  **Pulling Image**

  * If you are using ARM computer like M Chipset macbooks you should use *ARM64* at the end.

  ```console
  docker pull upsonic/gca_docker_ubuntu:dev0-AMD64
  ```

  **Starting container**

  ```console
  docker run -d -p 5901:5901 -p 7541:7541 upsonic/gca_docker_ubuntu:dev0-AMD64
  ```

  **LLM Settings&Using**

  ```python
  from gpt_computer_assistant import docker


  instance = docker.instance("http://localhost:7541/")


  instance.client.save_models("gpt-4o")
  instance.client.save_openai_api_key("sk-**")
  instance.client.save_anthropic_api_key("sk-**")


  result = instance.request("Extract the tech stacks of gpt-computer-assitant Company", "i want a list")
  print(result)

  instance.close()
  ```


  <p align="center">
  <br>
  <br>
  </p>



  <b>Installation</b>
  ```console
  pip install 'gpt-computer-assistant[base]'
  pip install 'gpt-computer-assistant[api]'
  ```

  <b>LLM Settings&Using</b>

  ```python
  from gpt_computer_assistant import local


  instance = local.instance()


  instance.client.save_models("gpt-4o")
  instance.client.save_openai_api_key("sk-**")
  instance.client.save_anthropic_api_key("sk-**")


  result = instance.request("Extract the tech stacks of gpt-computer-assitant Company", "i want a list")
  print(result)

  instance.close()
  ```


  <img width="1000" src="https://github.com/user-attachments/assets/327cdceb-49e7-4a8a-a724-e386553f43d8">


  <p align="center">
  <br>
    <br>
    <br>
  </p>





  ```python
  instance.client.add_mcp_server("websearch", "npx", ["-y", "@mzxrai/mcp-webresearch"])
  ```





  | Feature                         | Status       | Target Release |
  |---------------------------------|--------------|----------------|
  | Clear Chat History         | Completed    | Q2 2024        |
  | Long Audios Support (Split 20mb)      | Completed    | Q2 2024        |
  | Text Inputs               | Completed      | Q2 2024        |
  | Just Text Mode (Mute Speech)           | Completed  | Q2 2024        |
  | Added profiles (Different Chats)          | Completed    | Q2 2024        |
  | More Feedback About Assistant Status                  | Completed    | Q2 2024        |
  | Local Model Vision and Text (With Ollama, and vision models)  | Completed  | Q2 2024        |
  | **Our Customizable Agent Infrastructure**              | Completed      | Q2 2024        |
  | Supporting Groq Models  | Completed  | Q2 2024        |
  | **Adding Custom Tools**  | Completed  | Q2 2024        |
  | Click on something on the screen (text and icon)              | Completed      | Q2 2024        |
  | New UI              | Completed      | Q2 2024        |
  | Native Applications, exe, dmg              | Completed     | Q3 2024        |
  | **Collaborated Speaking Different Voice Models on long responses.**              | Completed     | Q2 2024        |
  | **Auto Stop Recording, when you complate talking**              | Completed     | Q2 2024        |
  | **Wakeup Word**              | Completed     | Q2 2024        |
  | **Continuously Conversations**              | Completed     | Q2 2024        |
  | **Adding more capability on device**              | Completed     | Q2 2024        |
  | **Local TTS**              | Completed     | Q3 2024        |
  | **Local STT**              | Completed     | Q3 2024        |
  | Tray Menu              | Completed     | Q3 2024        |
  | New Line (Shift + Enter)              | Completed     | Q4 2024        |
  | Copy Pasting Text Compatibility            | Completed     | Q4 2024        |
  | **Global Hotkey**              | On the way     | Q3 2024        |
  | DeepFace Integration (Facial Recognition)                    | Planned  | Q3 2024        |








  At this time we have many infrastructure elements. We just aim to provide whole things that already in ChatGPT app.

  | Capability                         | Status                      |
  |------------------------------------|----------------------------------|
  | **Local LLM with Vision (Ollama)**                    |            OK                    |
  | Local text-to-speech                    |            OK                    |
  | Local speech-to-text                    |            OK                    |
  | **Screen Read**                    |            OK                    |
  | **Click to and Text or Icon in the screen**                    |            OK                    |
  | **Move to and Text or Icon in the screen**                    |            OK                    |
  | **Typing Something**                    |            OK                    |
  | **Pressing to Any Key**                    |            OK                    |
  | **Scrolling**                    |            OK                    |
  | **Microphone**                     |            OK                    |
  | **System Audio**                  |            OK                    |
  | **Memory**                         |            OK                    |
  | **Open and Close App**             |            OK                    |
  | **Open a URL**                     |            OK                    |
  | **Clipboard**                       |            OK                    |
  | **Search Engines**                 |            OK                    |
  | **Writing and running Python**     |            OK                    |
  | **Writing and running SH**    |            OK                    |
  | **Using your Telegram Account**    |            OK                    |
  | **Knowledge Management**           |            OK                    |
  | **[Add more tool](https://github.com/onuratakan/gpt-computer-assistant/blob/master/gpt_computer_assistant/standard_tools.py)**           |            ?                    |


  If you enable it your assistant will work with these teams:

  | Team Name                         | Status                      |
  |------------------------------------|----------------------------------|
  | **search_on_internet_and_report_team**                    |            OK                    |
  | **generate_code_with_aim_team_**                    |            OK                    |
  | **[Add your own one](https://github.com/onuratakan/gpt-computer-assistant/blob/master/gpt_computer_assistant/teams.py)**                    |            ?                    |



    <a href="#">
      <img src="https://github.com/onuratakan/gpt-computer-assistant/assets/41792982/ba590bf8-6059-4cb6-8c4e-6d105ce4edd2" alt="Logo"  >
    </a>






  <a href="https://github.com/onuratakan/gpt-computer-assistant/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=onuratakan/gpt-computer-assistant" />
  </a>


pkgId: 37c9359831a6c0652b77f7af5e1e9eaab491872839ad311878a290ab95af8bf3
name: python-gcloud-aio-datastore-help
arch: noarch
version: 8.2.0
epoch: 0
release: 1
summary: Development documents and examples for gcloud-aio-datastore
url: https://github.com/talkiq/gcloud-aio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gcloud-aio-datastore-8.2.0-1.src.rpm
location_href: Packages/python-gcloud-aio-datastore-help-8.2.0-1.noarch.rpm
checksum_type: sha256
description:
      This is a shared codebase for ``gcloud-aio-datastore`` and
      ``gcloud-rest-datastore``
  |pypi| |pythons|


pkgId: 899998ca5da577ae4937411989a6489978c1b83fc841bf629206fff2679e02a1
name: python-gcloud-rest-datastore-help
arch: noarch
version: 8.2.0
epoch: 0
release: 1
summary: Development documents and examples for gcloud-rest-datastore
url: https://github.com/talkiq/gcloud-aio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gcloud-rest-datastore-8.2.0-1.src.rpm
location_href: Packages/python-gcloud-rest-datastore-help-8.2.0-1.noarch.rpm
checksum_type: sha256
description:
      This is a shared codebase for ``gcloud-rest-datastore`` and
      ``gcloud-rest-datastore``
  |pypi| |pythons|


pkgId: dd0f80f75140e2283e095f6d15f6536cc86a03f1ac6f78185a4a5ac7f52599f4
name: python-gda-importer-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for gda-importer
url: https://pypi.org/project/gda-importer/
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gda-importer-1.4.0-1.src.rpm
location_href: Packages/python-gda-importer-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  GDA Importer contains simple utilities that are helpful for installation and CI/CD of python packages.  Install with

  ```bash
  pip install -U gda-importer
  ```

  and use the scripts `ppinfo` and `pull-private-deps`, described below.
  The only dependencies are [toml](https://pypi.org/project/toml/) and [packaging](https://pypi.org/project/packaging/).



  `ppinfo` reads the contents of `pyproject.toml` files. It can be accessed as `python -m gda_importer.ppinfo` or as the installed script `ppinfo`.

  Run `ppinfo -h` for details.



  `pull-private-deps` installs dependencies specified in a `private-deps.toml` by whatever means necessary.

  **Why**?  We at GDA have many internal packages that are developed privately and require authentication. Unfortunately, it is not possible to give this specification in `pyproject.toml` or `environment.yml` because those sources do not provide authentication for private repositories. The `pull-private-deps.py` script allows us to install our code in different environments easily. **If [PEP 708](https://peps.python.org/pep-0708/#alternate-locations-metadata) is ever finished, then some parts of this will become uneccesary.** However, we also support different methods of installation, such as docker or local clones.
  We foresee a future where most of this functionality it replaced by newer tools like `uv` but we aren't there yet.



  The `private-deps.toml` file has stanzas for each dependency.
  The options in each stanza lead to different installation commands.
  Let's examine each of these cases.



  ```toml
  ["example-package[option1,option2]"]
    gitlab_host = "gitlab.example.com"
    gitlab_path = "groupname/projectname"
  ```

  If `CI_JOB_TOKEN` is available, this results in pulling a wheel over HTTPS.

  ```bash
  pip install -v example-package[option1,option2] --index-url https://gitlab-ci-token:$CI_JOB_TOKEN@gitlab.example.com/api/v4/projects/groupname%2Fprojectname/packages/pypi/simple
  ```

  If `CI_JOB_TOKEN` is missing, this results in pulling source over SSH.

  ```bash
  pip install -v example-package[option1,option2]@git+ssh://git@gitlab.example.com/groupname/projectname.git
  ```



  Use `version_set` to specify a specific version or range of versions for installation of prebuilt wheels from a PyPI-style registry.

  ```toml
  ["example-package[option1,option2]"]
    gitlab_host = "gitlab.example.com"
    gitlab_path = "groupname/projectname"
    version_set = ">=1.0,<3.0"
  ```

  If `CI_JOB_TOKEN` is available, this results in pulling a wheel over HTTPS, with pip checking versions.

  ```bash
  pip install -v example-package[option1,option2]<3.0,>=1.0 --index-url https://gitlab-ci-token:$CI_JOB_TOKEN@gitlab.example.com/api/v4/projects/groupname%2Fprojectname/packages/pypi/simple
  ```

  If `CI_JOB_TOKEN` is missing, this results in pulling source over SSH, and `version_set` will be ignored.

  ```bash
  pip install -v example-package[option1,option2]@git+ssh://git@gitlab.example.com/groupname/projectname.git
  ```



  If `force_src = true`, then a `gitlab_spec` must be specified, and `version_set` is irrelevant.
  Use `gitlab_spec` to specify a specifig git reference for installation from source.

  ```toml
  ["example-package[option1,option2]"]
    gitlab_host = "gitlab.example.com"
    gitlab_path = "groupname/projectname"
    force_src = true
    gitlab_spec = "branch-or-commit-or-tag-ref"
  ```

  If `CI_JOB_TOKEN` is available, this results in pulling source over HTTPS.

  ```bash
  pip install -v example-package[option1,option2]@git+https://gitlab-ci-token:$CI_JOB_TOKEN@gitlab.example.com/groupname/projectname.git@branch-or-commit-or-tag-ref
  ```

  If `CI_JOB_TOKEN` is missing, this results in pulling source over SSH.

  ```bash
  pip install -v example-package[option1,option2]@git+ssh://git@gitlab.example.com/groupname/projectname.git@branch-or-commit-or-tag-ref
  ```



  The `version_set` option is for version sets given by pip-style conditions.  This only applies to package registries with the `force_src = false` option.

  The `gitlab_spec` option is for gitlab references (branch names, commit hashes, tags) and only applies if `force_src = true`.

  If `gitlab_spec` and `version_set` are both specified and `force_src = true`, then to avoid confusion they are checked for consistency. If `gitlab_spec` looks like a semantic version (for example, the tag `v3.0.1`), it will be checked against `version_set`, and a warning will be issued if they do not match.

  ```toml
  ["example-package[option1,option2]"]
    gitlab_host = "gitlab.example.com"
    gitlab_path = "groupname/projectname"
    gitlab_spec = "v3.0.1"
    version_set = ">=1.0,<3.0"
  ```

  `ValueError: Version implied by gitlab_spec is not included in the version_set.`



  There are several ways to pull the code, overriding the contents of the toml file. We list them from most self-contained to most messy.

  Consider the following toml.

  ```toml
  ["package-name[extra,option]"]
    gitlab_host = "gitlab.example.com"
    gitlab_path = "path/to/project"
    gitlab_spec = "v1.0.1"
    version_set = "==1.0.1"
    token_var = "FAKE_TOKEN
  ```

  The default behavior can be overridden with `--method`



  The standard GDA CI/CD pipeline builds Docker containers for any project that involves API endpoints.

  Try this and remove the `--dry_run` if you are happy with the result.

  ```bash
  pull-private-deps --dry_run --toml private-deps.toml --method docker
  ```

  This produces an output like the following.

  ```bash
  docker login gitlab.example.com:5115 -u git -p $FAKE_TOKEN
  docker pull gitlab.example.com:5115/path/to/project:v1-0-1
  docker run -p 8000:80 gitlab.example.com:5115/path/to/project:v1-0-1
  ```



  The standard GDA CI/CD pipeline builds pip-installable wheels for any project that involves Python.

  Try this and remove the `--dry_run` if you are happy with the result.

  ```bash
  pull-private-deps --dry_run --toml private-deps.toml --method wheel
  ```

  This produces an output like the following.

  ```bash
  pip install "package-name[extra,option]==1.0.1" --index-url "https://gitlab-ci-token:$FAKE_TOKEN@gitlab.example.com/api/v4/projects/path%2Fto%2Fproject/packages/pypi/simple"
  ```



  Pip allows installation directly from git repositories.
  This method may require additional work to prepare your build environment.

  Try this and remove the `--dry_run` if you are happy with the result.

  ```bash
  pull-private-deps --dry_run --toml private-deps.toml --method source
  ```

  This produces an output like the following.

  ```bash
  pip install package-name[extra,option]@git+https://gitlab-ci-token:$FAKE_TOKEN@gitlab.example.com/path/to/project.git@v1.0.1
  ```



  If all else fails, you can clone the repository, build, and install. This is the *least*-preferred option and the most likely to fail.

  Try this and remove the `--dry_run` if you are happy with the result.

  ```bash
  pull-private-deps --dry_run --toml private-deps.toml --method clone
  pull-private-deps --dry_run --toml private-deps.toml --method local
  ```

  This produces an output like the following.

  ```bash
  git clone -b v1.0.1 https://gitlab:$FAKE_TOKEN@gitlab.example.com/path/to/project.git package-name
  pip install ./package-name
  ```



  - Package name must satisfy  [PyPA guidelines](https://packaging.python.org/en/latest/specifications/dependency-specifiers/#names)
  - Extra options must satisfy [PyPA guidelines](https://packaging.python.org/en/latest/specifications/dependency-specifiers/#extras)

  - `pip install` on your main package will be **unaware** of these dependencies, because these private-repository dependencies are installed after the other types of dependencies, and must be re-installed for each job in the CI/CD pipeline.
  Therefore, for pipeline efficiency, *you should make sure that [pyproject.toml](pyproject.toml) or [environment.yml](environment.yml) contain whatever second-order public dependencies will be needed.*

  - If any of the included private dependencies have any **Anaconda Binary Dependencies** (see the next section), then these binary dependencies **must be manually added** to [environment.yml](environment.yml).



  Regardless of how you follow the User Installation subsection below, be sure to check if there are any additional, `conda`-specific requirements for the package specified in `environment.yml`.

  If there are any dependencies there other than the [cookiecutter defaults](https://gitlab.geomdata.com/geomdata/gda-cookiecutter/-/blob/master/environment.yml?ref_type=heads), then these may be important to include in a working conda environment wherever you intend to use this package. If there are no additional dependencies there, then this step can be disregarded.


pkgId: 6ff95996000f0f7ad9502a24a80ef149032b36f6ffd7fd0390f870d05041c0bf
name: python-gdmo-help
arch: noarch
version: 0.0.75
epoch: 0
release: 1
summary: Development documents and examples for gdmo
url: https://github.com/StephanKuiper-Insight/gdmo
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gdmo-0.0.75-1.src.rpm
location_href: Packages/python-gdmo-help-0.0.75-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/gdmo.svg)](https://pypi.org/project/gdmo/)
  [![Tests](https://github.com/StephanKuiper-Insight/gdmo/actions/workflows/test.yml/badge.svg)](https://github.com/StephanKuiper-Insight/gdmo/actions/workflows/test.yml)
  [![Changelog](https://img.shields.io/github/v/release/StephanKuiper-Insight/gdmo?include_prereleases&label=changelog)](https://github.com/StephanKuiper-Insight/gdmo/releases)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/StephanKuiper-Insight/gdmo/blob/main/LICENSE)




  This custom library allows our engineering team to use standardized packages that strip away a load of administrative and repetitive tasks from their daily object interactions. The current classes supported (V0.1.0) are:




  Install this library using `pip`:
  ```bash
  pip install gdmo
  ```



  Standardized way of forecasting a dataset. Input a dataframe with a Series, a Time, and a Value column, and see the function automatically select the right forecasting model and generate an output.

  Example usage:

  ```python
  from gdmo import TimeSeriesForecast
  forecaster = TimeSeriesForecast(spark, 'Invoiced Revenue')\
                      .set_columns('InvoiceDate', 'ProductCategory', 'RevenueUSD')\
                      .set_forecast_length(forecast_length)\
                      .set_last_data_point(lastdatamonth)\
                      .set_input(df)\
                      .set_growth_cap(0.02)\
                      .set_use_cap_growth(True)\
                      .set_modelselection_breakpoints(12, 24)\
                      .set_track_outcome(False)\
                      .build_forecast()

  forecaster.inspect_forecast()
  ```


  Class to perform a standard API Request using the request library, which allows a user to just add their endpoint / authentication / method data, and get the data returned without the need of writing error handling or need to understand how to properly build a request.

  Example usage:

  ```python

  request = APIRequest(uri)\
              .set_content_type('application/json') \
              .set_header('bearer xxxxx') \
              .set_method('GET') \
              .set_parameters({"Month": "2024-01-01"})\
              .make_request()

  response = request.get_json_response()
  display(response)
  ```


  A class for landing API ingests and other data into Azure Data Lake Storage (ADLS). Currently can ingest Sharepoint (excel) data and JSON (API-sourced) data. The class can load data three ways: overwriting data, appending data (with check for existing filenames, marking older entries as IsDeleted = 1), or merge data in. When using a merge, the config data needs joincolumns to perform the merge on.

  Example usage to ingest files from Sharepoint folder:

  ```python

  environment     = 'xxxxx' #Databricks catalog

  Sharepointsite  = 'xxxxx'
  UserName        = 'xxxxx'
  Password        = 'xxxxx'
  Client_ID       = 'xxxxx'
  adls_temp       = 'xxxxx'

  sharepoint = Landing(spark, dbutils, database="xxx", bronze_table="xxx", catalog=environment, container='xxx')\
                    .set_tmp_file_location(adls_temp)\
                    .set_sharepoint_location(Sharepointsite)\
                    .set_sharepoint_auth(UserName, Password, Client_ID)\
                    .set_auto_archive(False)\
                    .get_all_sharepoint_files()

  ```

  If you need to capture logging on top of these ingests, follow up the code with the get_log() function
  ```python
  try:
    log = sharepoint.get_log()
    
    sql_query = f"""
      INSERT INTO {logtable}
      SELECT now() DbxCreated, '{log['database']}', '{log['bronze_table']}', '{log['catalog']}', '{log['file_path']}', {log['records_influenced']}, '{log['start_time']}', '{log['end_time']}'
      """

    
    spark.sql(sql_query)
  except Exception as e:
    raise e
  ```


  Example usage to ingest JSON content from an API:

  ```python

  uri = 'xxxxx'
  request  = APIRequest(uri).make_request()
  response = request.get_json_response()


  landing = Landing(spark, dbutils, database="xxx", bronze_table="xxx", target_folder=location, filename=filename, catalog=environment, container='xxx')\
                  .set_bronze(bronze)\
                  .set_config(config)\
                  .put_json_content(response)\
                  .put_bronze()

  ```


  Class to enable you to create a delta table on azure databricks. Supports the ability to assign a primary key, foreign key constraints, table properties, partitioning, identity column, and more.

  Example usage to create a delta table with a primary key and a foreign key:

  ```python
  from gdmo import Delta

  table = Delta(db_name,table_name, spark, env, container)\
              .set_columns([
                  {"name": "DbxCreated",   "data_type": "timestamp",  "comment": "Date when data was last loaded into source tables"},
                  {"name": "DbxUpdated",   "data_type": "timestamp",  "comment": "Last modified timestamp"},
                  {"name": "IsDeleted",    "data_type": "int",        "comment": "Deleted Flag"},
                  {"name": "DataSource",   "data_type": "string",     "comment": "Identifies the source of the record."},
                  {"name": "PK_ValueCol1", "data_type": "int",        "comment": "Primary Key column. Numeric value"},
                  {"name": "ValueCol2",    "data_type": "string",     "comment": "Value column one"},
                  {"name": "FK_ValueCol3", "data_type": "date",       "comment": "Value column two, which is a foreign key"},
                ])\
              .set_comment(table_comment)\
              .set_location(table_location)\
              .set_partitioning('DataSource')\
              .drop_existing()\
              .create_table()\
              .set_primary_key('NCC_PKValueCol1', 'PK_ValueCol1')

  foreign_keys = [
      {'name': 'NCC_FKValueCol3', 'columns': 'FK_ValueCol3', 'table': 'schema.othertable'}
  ]

  table.set_foreign_keys(foreign_keys)

  ```


  A class to perform gold layer (see databricks medallion architecture) consolidation of records. This class is usable when you have a gold table that should consist of unique records, or a timeseries dataset, which need to be sourced from multiple sources, each offering roughly the same dataset. Example usage is if you want a single gold customer table, but there are two raw sources of customer data (multiple ERP systems for example), but both offer the same sort of data.

  In order to use this class, one would need a control table to contain all unique (SQL) source codes to retrieve data in a standard format from the silver layer. By default, this class assumes there is a delta table located at "admin.bronze__gold_consolidation_sources". If that is not present, start by creating one like this:
  ```python
  from gdmo import Delta
  import os
  env = os.environ['Environment']

  container = '{enter container name here}'
  db_name = 'admin'
  table_name = 'bronze__gold_consolidation_sources'

  location = os.environ.get("ADLS").format(container=container, path=db_name)
  table_location = f'{location}/{table_name.replace("__", "/").lower()}'

  table = Delta(db_name,table_name, spark, env, container)\
              .set_columns([
                    {"name": "DbxCreated",      "data_type": "timestamp", "comment": "Creation date in databricks"},
                    {"name": "DbxUpdated",      "data_type": "timestamp", "comment": "Last updated date"},
                    {"name": "IsDeleted",       "data_type": "int",       "comment": "Deletion Flag"},
                    {"name": "TableName",       "data_type": "string",    "comment": "Complete gold table name. IE: sales__invoices"},
                    {"name": "SourceName",      "data_type": "string",    "comment": "silver table name consolidating into the gold layer"},
                    {"name": "SourceCode",      "data_type": "string",    "comment": "sql code required to pull data from silver"},
                    {"name": "InlineVar",       "data_type": "string",    "comment": "optional. the silver sql code can contain a var in the filtering clause when loading for example only partial data for performance. this contains the varname inline in the code as a python list of dicts. , so we can do a text.replace on it. "},
                    {"name": "SortOrder",       "data_type": "int",       "comment": "When consolidation uses unique records this order is used to order the sources by importance. Lower value = higher priority. 1 = highest priority"}
                ])\
              .set_comment('Holds the silver sql codes to retrieve data for gold layer consolidation tables. ')\
              .set_location(table_location)\
              .drop_existing()\
              .create_table()\
              .set_primary_key('TableName, SourceName')
  ```

  When ready, then add sources to this dataset by using the below code. In this example, each sourcecode contains a catalog var inline in the sql, which needs to be replaceable by a python var during runtime (called InlineVar):

  ```python
  from gdmo import Gold_Consolidation

  db_name    = 'gold'
  table_name = 'tablename'
  inlinevar  = '\'[catalog]\']' #stringified python list
  SortOrder  = 1 #Numeric value used for deduplication of unique records when asked to

  gold = Gold_Consolidation(spark, dbutils, database=db_name,gold_table=table_name)

  SourceName =  'SilverDataSourceOne'
  SourceCode = f'''
      SELECT  columns
      FROM [catalog].silvertable
      ...This should be your bespoke transformational layer to retrieve the records in the shape you need it in for gold. the column list should be identical to the gold table column list.
      '''

  gold.set_source(SourceName = SourceName, SourceCode = SourceCode, InlineVar = inlinevar, SortOrder=SortOrder)

  ```

  Once sourcecodes are added to the control table, we can use a scheduled notebook (workflow) in databricks to pull data into the gold layer. The basic way of doing this is in below example:

  ```python
  from gdmo import DbxWidget, Gold_Consolidation, DbxClearCachedTables
  import os

  db_name    = 'gold'
  table_name = 'tablename'

  final_table = db_name+'.'+table_name
  stage_table = final_table+'_stage'

  catalog       = DbxWidget(dbutils, 'catalog', defaultValue = os.environ.get('Environment'))
  verbose       = DbxWidget(dbutils, 'verbose', defaultValue = 'N')


  MetaTables = ['metatable']
  DbxClearCachedTables(spark, MetaTables)

  meta = spark.sql(f'''CACHE TABLE metadata AS SELECT * from somewheremetadata''')


  gold = Gold_Consolidation(spark, dbutils, database=db_name,gold_table=table_name)
  gold.set_catalog(catalog)


  config = {
      'partitioncolumns': ['DataSource'],   #Required when loadtype is merge and the class is running in parallel (which is default)
      'loadType':         'merge',          #[Options: merge | append | overwrite]
      'loadmechanism':    'uniquevalues',   #[Options: timeseries | uniquevalues]
      'joincolumns':      ['PKColOne']      #Required when loadtype is merge
  }
  gold.set_config(config)


  if verbose == 'Y':
    gold.set_verbose()


  gold.get_sourcecodes()
  gold.clean_stage()


  gold.set_inlinevar({'[catalog]': catalog})


  gold.set_stage()


  gold.set_final()


  gold.clean_stage()


  DbxClearCachedTables(spark, MetaTables)


  if verbose == 'Y':
    df = spark.sql(f'''
                    SELECT DataSource, COUNT(*) Recs
                    FROM {final_table}
                    group by DataSource
                    ''')
    df.display()
  ```



  A class for generating and reading a databricks notebook widget. The widget supports all four widget types (['text', 'dropdown', 'multiselect', 'combobox']) and allows for different response datatypes to be set ['text', 'int', 'double', 'float','date']

  The default databricks method:
  ```python
  dbutils.widgets.dropdown("colour", "Red", "Enter Colour", ["Red", "Blue", "Yellow"])
  colour = dbutils.widgets.read("colour")
  ```

  Using this function all the user needs to write is:
  ```python
  colour = DbxWidget(dbutils, "colour", 'dropdown', "Red", choices=["Red", "Blue", "Yellow"])
  ```

  A simple text value parameter:
  ```python
  reloadData = DbxWidget(dbutils, "fullReload", 'N')
  ```

  A simple date value parameter:
  ```python
  reloadData = DbxWidget(dbutils, "startDate", 'N', returntype='date')
  ```


  A class to simply input a list of cached table names to, which will then uncache them all.

  ```python
  MetaTables = ['CachedTableOne','CachedTableTwo','CachedTableThree']

  DbxClearCachedTables(spark, MetaTables)

  ```


pkgId: 578d767af53f0c0a368d262facfabf76ea4df4479e4b0aaf4b215a67295a8a29
name: python-gdrive-core-help
arch: noarch
version: 1.3
epoch: 0
release: 1
summary: Development documents and examples for gdrive-core
url: https://github.com/YourAverageDev/gdrive-core
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gdrive-core-1.3-1.src.rpm
location_href: Packages/python-gdrive-core-help-1.3-1.noarch.rpm
checksum_type: sha256
description:
  A minimal and functional Google Drive API wrapper for Python. Easily perform Google Drive file operations like upload, download, list, delete, and manage metadata with an intuitive class-based interface.



  - **Flexible Authentication**: Supports OAuth2 and Service Account authentication.
  - **File Management**: Upload (with progress tracking), download (with progress tracking), list, and delete files effortlessly. Supports streamed uploads/downloads.
  - **Folder Management**: Create folders and organize files.
  - **Custom Metadata**: Add and manage arbitrary custom properties to files, and update metadata.
  - **Batch Operations**: Delete multiple files at once using parallel processing.
  - **Advanced Search**: Search for files using multiple criteria such as name, MIME type, and trashed status.
  - **File Sharing**: Share files with specific permissions.
  - **File Revisions**: Access a file's revision history.
  - **Copy Files**: Create copies of existing files.
  - **Storage Quota**: Retrieve information about your Google Drive storage usage.
  - **Push Notifications**: Set up webhooks to watch for file changes.
  - **File Export**: Export Google Workspace files in various formats.
  - **OOP Interface**: Interact with Google Drive through a clean, class-based API.
  - **Logging**: Integrated logging for better monitoring and debugging.
  - **Retry Mechanism**: Automatic retries for API calls to handle transient errors.
  - **Path-based Operations**: Work with Google Drive using familiar path strings (e.g., 'folder1/folder2/file.txt')
  - **Context Manager Support**: Clean resource management using Python's `with` statement
  - **Simplified File Operations**: High-level methods for common tasks
  - **Automatic Folder Creation**: Create nested folder structures with a single call
  - **Batch Processing**: Upload, download, or delete multiple files in parallel




  Install the package using pip:

  ```bash
  pip install gdrive-core
  ```



  Before using `gdrive-core`, ensure you have:

  1. **Google Cloud Credentials**:
     - Go to the [Google Cloud Console](https://console.cloud.google.com/).
     - Enable the **Google Drive API** for your project.
     - Download the `credentials.json` file for either an OAuth 2.0 Client ID or a Service Account.
     - Place the `credentials.json` file in your working directory.
     - **For OAuth2:**
          - The first time you run the program with OAuth2, it will prompt you to authenticate via a browser.
          - A `token.json` file will be created to store access tokens for future use.
     - **For Service Account:**
          - No `token.json` file is necessary as credentials are managed by the `credentials.json` file.





  Initialize the `GDriveCore` client for interacting with Google Drive. You can choose between `oauth2` and `service_account` authentication types.

  ```python
  from gdrive_core import GDriveCore


  client = GDriveCore(auth_type='oauth2', credentials_file='credentials.json', token_file='token.json')



  ```



  Upload a file to Google Drive, optionally adding custom properties and using a callback function to track progress.

  ```python
  def upload_progress(progress):
      print(f"Upload progress: {progress:.2f}%")


  file_id = client.upload('example.txt', properties={'is-penguin': 'true', 'category': 'animal'}, progress_callback=upload_progress)
  print(f"Uploaded file ID: {file_id}")
  ```



  List files in the root directory or filter files using queries.

  ```python

  files = client.list_files()
  print("Files in Drive:")
  for f in files:
      print(f"- {f['name']} (ID: {f['id']})")
  ```



  Download a file from Google Drive using its file ID. You can track the progress using a callback function.

  ```python
  def download_progress(progress):
      print(f"Download progress: {progress:.2f}%")


  download_path = 'downloaded_example.txt'
  client.download(file_id, download_path, progress_callback=download_progress)
  print(f"File downloaded to: {download_path}")
  ```



  Create a new folder in Google Drive to organize your files.

  ```python

  folder_id = client.create_folder('NewFolder')
  print(f"Folder created with ID: {folder_id}")
  ```



  Move an existing file into a specific folder.

  ```python

  client.move(file_id, new_parent_id=folder_id)
  print("File moved successfully!")
  ```



  Update a file's name or description.

  ```python

  client.update_metadata(file_id, metadata={'name': 'renamed_example.txt', 'description': 'Updated metadata'})
  print("File metadata updated!")
  ```



  Search for files matching specific criteria like name, MIME type, and trashed status.

  ```python

  results = client.search(query_params={'name_contains': 'example', 'mime_type': 'text/plain', 'trashed': 'false'})
  print("Search results:")
  for file in results:
      print(f"- {file['name']} (ID: {file['id']})")
  ```



  Delete multiple files at once by providing their file IDs.

  ```python

  deletion_results = client.batch_delete([file_id])
  print(f"Files deleted successfully: {deletion_results}")
  ```



  Share a file with another user with a specific role (e.g., reader, writer).

  ```python

  share_result = client.share(file_id, email='user@example.com', role='reader')
  print(f"File shared successfully: {share_result}")
  ```



  Get a list of previous versions (revisions) of a file.

  ```python

  revisions = client.get_file_revisions(file_id)
  print(f"File revisions: {revisions}")
  ```



  Create a copy of an existing file.

  ```python

  copied_file_id = client.copy_file(file_id, new_name='example_copy.txt')
  print(f"Copied file ID: {copied_file_id}")
  ```



  Retrieve the storage usage of your Google Drive.

  ```python

  quota = client.get_storage_quota()
  print(f"Storage quota: {quota}")
  ```



  Set up a webhook to receive notifications when the file is modified.

  ```python

  watch_response = client.watch_file(file_id, webhook_url='https://your-webhook-url.com')
  print(f"Watch setup result: {watch_response}")
  ```



  Export a Google Workspace file to a specific format.

  ```python

  exported_file = client.export_file(file_id, mime_type='application/pdf')
  with open('exported.pdf', 'wb') as f:
      f.write(exported_file.read())
  print(f"File exported to 'exported.pdf'")
  ```



  The simplest way to use gdrive-core is with the context manager:

  ```python
  from gdrive_core import GDriveCore

  with GDriveCore() as drive:
      
      folder_id = drive.get_or_create_folder('Projects/2024/Reports')
      file_id = drive.upload_file('monthly_report.pdf', folder_id)
  ```



  Work with Google Drive using familiar path strings:

  ```python
  with GDriveCore() as drive:
      
      file_id = drive.path_to_id('Projects/2024/Reports/monthly_report.pdf')

      
      folder_id = drive.get_or_create_folder('Projects/2024/Reports')
  ```



  Upload or delete multiple files efficiently:

  ```python
  with GDriveCore() as drive:
      
      files_to_upload = ['file1.txt', 'file2.pdf', 'file3.docx']
      results = drive.batch_upload(files_to_upload, folder_id)

      
      files_to_delete = ['id1', 'id2', 'id3']
      deletion_results = drive.batch_delete(files_to_delete)
  ```



  Search for files using intuitive parameters:

  ```python
  with GDriveCore() as drive:
      
      docs = drive.search({
          'type': 'document',
          'parent': folder_id,
          'name': 'Monthly Report'
      })

      
      folders = drive.search({
          'type': 'folder',
          'trashed': False
      })
  ```



  Here's a complete example showcasing the intuitive features:

  ```python
  from gdrive_core import GDriveCore

  with GDriveCore() as drive:
      
      folder_id = drive.get_or_create_folder('Projects/2024/Reports')

      
      files_to_upload = ['report1.pdf', 'report2.pdf', 'data.xlsx']
      upload_results = drive.batch_upload(files_to_upload, folder_id)

      
      pdfs = drive.search({
          'type': 'pdf',
          'parent': folder_id
      })

      
      for pdf in pdfs:
          drive.download(pdf['id'], f"downloaded_{pdf['name']}")

      
      drive.share(folder_id, 'colleague@company.com', role='writer')

      
      metadata = drive.get_file_metadata(folder_id)
      print(f"Folder size: {metadata.get('size', 'N/A')} bytes")
  ```



  Here are some common operations and their simplified syntax:

  ```python
  with GDriveCore() as drive:
      
      folder_id = drive.get_or_create_folder('Path/To/Folder')

      
      file_id = drive.upload_file('document.pdf', folder_id)

      
      file_id = drive.path_to_id('Path/To/Folder/document.pdf')

      
      results = drive.search({
          'name': 'document.pdf',
          'type': 'pdf',
          'trashed': False
      })

      
      drive.batch_upload(['file1.txt', 'file2.txt'], folder_id)
      drive.batch_delete(['file_id1', 'file_id2'])
  ```



  - **Missing `credentials.json`**: Ensure the `credentials.json` file is placed in the working directory.
  - **Token Issues (OAuth2)**: If you face authentication problems, delete the `token.json` file and re-authenticate.
  - **Service Account Issues**: Ensure the service account has the necessary permissions to access your Google Drive.
  - **Custom Metadata**: Ensure custom property keys and values conform to Google Drive's property limitations.
  - **Rate Limits**: Google Drive API has rate limits. If you encounter issues, consider implementing retry mechanisms or exponential backoff.



  `gdrive-core` is released under the MIT License.


