Saravanan666/pypi-org huggingface dataset:
Package: vuabl
Visualizer for Unity Addressables build layoutVisualizer for Unity Addressables build layoutor justvuablis a small app, that tries to simplify the task of optimizing the build size in Unity projects with theAddressables systemRequirementsPython 3.6 or higherpipAdditional requirements on Windows platform:Windows SDK (required by numpy)MSVC C++ Build tools (required by numpy)InstallationOn Windows:pipinstallvuablOr:py-mpipinstallvuablOn other systems:pip3installvuablOr:python3-mpipinstallvuablUsageSimply run:vuablyour_buildlayout.txtIf the app doesn't open automatically in the browser, open the app's address
in your browser manually (by default it is127.0.0.1:8050)Example:If you don't know how to generate an Addressables build layout or where to find it,check thisOptionsYour can get a list of all supported options by adding-hor--helpto the command. For example:vuabl-h
Package: vuakhter
VuakhterVuakhter is validation tool to test API to conform ourAPI guide.
But it can be used to generate statistics of web-application by its logs.Principles of workVuakhter scans access log for specified period, filters log entries by path prefixes
and passes each entry for statistics generation.Base classAccessLogreturns an iterator of log entries. ClassElasticAccessLogscans elastic indices for log entries.StatisticsMetricsgetsAccessEntryrecords and forms array of statistics data.StatisticsMetrics.report() -> strreturns statistics report for the metrics.HttpAnalyzerusesaccess_log: AccessLogand array ofStatisticsMetrics.Only one metricSchemaValidatorCounteris passing toHttpAnalyzerin main scriptvuakhter. It usesrequest_log: RequestLogto validate API responses.ClassElasticRequestLog: RequestLogscans elastic indices requests by request_id
and returns array ofRequestEntry.SchemaValidatorCounterchecks all responses
bodies and counts valid API calls.InstallationpipinstallvuakhterUsagevuakhter [--es-user ES_USER] [--es-pass ES_PASS] [--es-host ES_HOST] [--es-port ES_PORT
[--start-date START_DATE] [--end-date END_DATE] prefixes [prefixes ...]By default end_date is current date and time if not specified. And start_date
defaults to day ago end_date.All connection parameters may be specified in .env file.ES_USER=elastic ES_PASS=pasword ES_HOST=localhost vuakhter /api/Using in codeimportdatetimefromelasticsearchimportElasticsearchfromvuakhter.analyzerimportHttpAnalyzerfromvuakhter.kibana.access_logimportElasticAccessLogfromvuakhter.metrics.countersimportComplexCounterelastic=Elasticsearch()access_log=ElasticAccessLog(index_pattern='filebeat-*',client=elastic)http_analyzer=HttpAnalyzer(access_log=access_log)http_analyzer.add_metrics(ComplexCounter())end_date=datetime.datetime.now()start_date=end_date-datetime.timedelta(days=1)http_analyzer.analyze(start_date,end_date)formetricinhttp_analyzer.metrics:metric.finalize()print(metric.report())ContributingWe would love you to contribute to our project. It's simple:Create an issue with bug you found or proposal you have.
Wait for approve from maintainer.Create a pull request. Make sure all checks are green.Fix review comments if any.Be awesome.Here are useful tips:You can run all checks and tests withmake check. Please do it
before TravisCI does.We useBestDoctor python styleguide.We respectDjango CoC.
Make soft, not bullshit.
Package: vuba
vubavuba(formerlycvu) is an easy to use library for constructingOpenCVHighGUI interfaces.Documentation:https://vuba.readthedocs.io/en/latest/Example scripts:https://github.com/EmbryoPhenomics/vuba/examplesInstallation:https://vuba.readthedocs.io/en/latest/installing.htmlSource code:https://github.com/EmbryoPhenomics/vuba/vubaWe developed this library to make coding up computer vision interfaces fast and efficient, allowing users to focus on their given application and bypass the challenges associated with developing a working user interface. We have since extended this to other areas of theOpenCVlibrary, writing wrappers where we feel the reduction in code verbosity improves both readability and reduces complexity in codebases.Currently the library is split up into three modules:gui-OpenCVHighGUI constructors, for both individual/multiple images and video sequences. These all share the same base constructor class, where the interfaces are constructed through a series of decorators. This enables users to create complex interfaces through a simple, declarative API.imio- Image readers and writers for handling various image formats. Note that regardless of format, the handlers share the same API.ops- Image operations, from simple drawing functions to contour filters and mask constructors.This library is still in active development and so we welcome feedback on any aspect ofvuba.
Package: vuc3
vuc3This is under review.vuc3.py is a Python program to invesitigate effects of vaccines on COVID-19 mortality and infection between the second booster, the fist booster, fully vaccinated and unvaccinated.CDC dataset is used for this study:https://data.cdc.gov/api/views/ukww-au2k/rows.csvvuc3 is a PyPI application which runs on Windows, MacOS, and Linux Operating Systems
as long as Python is installed on the system. Three determinants should be given to uvc3 such as age group (50-64, 65+ or all_ages), product (Pfizer, Moderna, Janssen, and all_types), and outcome (death or case).How to install vuc3$ pip install vuc3How to run vuc3$ vuc3 all_ages Pfizer death
Package: vud4
vud4This is under review.vud4.py is to calculate the time-series effect of vaccination on mortality in six age groups (18-29 years, 30-49 years, 50-64 years, 65-79 years, 80+ years, and all ages) for three vaccination types: bivalent booster, fully vaccinated, and unvaccinated. The CDC dataset for the period October 1, 2021 through January 23, 2023 was used for this study:https://data.cdc.gov/api/views/54ys-qyzm/rows.csvHow to install vud4$ pip install vud4How to run vud4$ vud4enter one of age groups: vud4 80+18-29,30-49,50-64,65-79,80+,all_ages$ vud4 80+
Package: vudo.skinsetup
IntroductionThis package provides an light-weight API forvudopackages which provide
user-changeable skins.  These packages may advertise their skin directory usingsetuptools entry points.Additionally, this package provides a script to manage the skin directory of avudoproject in a convenient way.UsageDevelopers, which want to makevudopackages which provide skins, need to
include their skin resources in the EGG, and include a entry point.Skin ResourcesDepending whether or not a SCM system supported by setuptools (currently SVN)
is used or not, developers may need to include their resources manually usingpackage_data:setup(name='vudo.compositepage',
      ...
      packages=find_packages('src'),
      package_dir = {'': 'src'},
      package_data = {
          "vudo.compositepage": [
              "skin/*.zcml",
              "skin/compositepage/*.zcml",
              "skin/compositepage/ajax/*.pt",
              "skin/region/*.pt",
              ]
          },
      ...
      )Entry PointAdditionally to include the skin resources in the package egg, the skin needs
to be advertized using aentry point:setup(name='vudo.compositepage',
      ...
      entry_points="""
      # -*- Entry points: -*-
      [vudo.skin]
      compositepage=vudo.compositepage:provide_skin [skin]
      """,
      extras_require={
          "skin": "vudo.skinsetup",
      },
      ...
  )Theprovide_skinmentioned above needs to call thevudo.skinsetuppackage API to return the skin information:def provide_skin():
    import os
    from vudo.skinsetup import provide_skin
    return provide_skin(
            package="vudo.compositepage",
            name="compositepage",
            skin_path="skin")the parameters to theprovide_skinmethod are as follows:packageThe package name which provides the skinnameThe skin nameskin_pathThepathto the skin within the package.  Note, this is usually asetuptoolsresource path, and thus always “/” separated.  Do not useos.path.LinksPkg resources and Entry Pointshttp://peak.telecommunity.com/DevCenter/PkgResources#entry-pointshttp://peak.telecommunity.com/DevCenter/PkgResources#resourcemanager-apiQuick tutorialhttp://wiki.pylonshq.com/display/pylonscookbook/Using+Entry+Points+to+Write+PluginsChange historyChangelog0.1 (2008-12-08)Script entry point forvudoskinscript. [seletz]Very basic API for vudo packages which want to provide a skin [seletz]Initial package setup. [seletz]ContributorsStefan Eletzhofer, AuthorDownload
Package: vuejspython
Vuejs-python brings the concepts of vuejs to Python.
You can write your model/data as a Python object and your HTML UI/view with the very convenient vuejs syntax.
As soon as part of your model changes, all dependent variables are updated and the HTML UI is automatically refreshed.The goal is to use not only Python the language but Python the platform (with numpy, system APIs, and other "native" things).Installationpip install vuejspythonTiny ExampleYou need to create two files: one Python model and an HTML UI.
A good convention (to help tools) is to use the same name, with the.pyand.htmlextensions, respectively.# example.py...@modelclassApp:radius=5defcomputed_area(self):returnpi*self.radius**2vuejspython.start(App())# example.html<divid="main">Fill the radius in the text field:<inputv-model.number="radius"/>.
      (or with<button@click="radius += 1">+1</button><br/>A disk with radius {{ radius }} has an area of {{ area }}.</div><scriptsrc="lib/vuejspython.js"></script><script>vuejspython.start()</script>Running, option 1: only with Pythonpython3example.py# or a tiny shell function helperpvue(){(sleep.5;firefox${1%.*}.html)&python3${1%.*}.py;}pvueexample.pyThis will give you an address to which you should append your HTML file name, hereexample.html.
In this example, you will visithttp://localhost:4260/example.html(or visit the given addresshttp://localhost:4260and click your file).NB: you need to stop the command withCtrl+Cif you want to run another example.Running, option 2: with hot reload on file changeHere we will start two processes, one for the HTML part (with live reload, and another only for the Python).Terminal 1, hosting the HTML files with hot reload:# one-time installpipinstallwatchdog
npminstall-gsimple-hot-reload-server# in terminal 1 (hot html reload, for all files)hrs.(this gives you the address to open, after appending your file name, e.g.,http://localhost:8082/example.html)Terminal 2, running the python server# in terminal 2 (start or restart python)NOSERVE=1python3example.py# OR, for live restartNOSERVE=1watchmedoauto-restart--patterns="*.py"python3example.pyNB:NOSERVE=1tells vuejspython to not serve the HTML files (it is handled byhrsabove)NB: when changing the .py, a manual browser refresh is still needed, see below for a more complete solutionHelper for complete live reload (live restart for python)pvue(){iftest"$1"=open;thenshift;(sleep1;firefox"http://localhost:8082/${1%.*}.html")&fi;watchmedoauto-restart--patterns="*.py"--ignore-patterns="*/.#*.py"bash---c'(sleep .250 ; touch '"${1%.*}"'.html) & python3 '"${1%.*}"'.py';}# Thenpvueexample# OR to also open firefoxpvueopenexample# OR some convenient variationsNOSERVE=1pvueopenexample
pvueopenexample.
pvueopenexample.py
pvueopenexample.html# it always runs the file with the .py extensionOther, different projectsIf you're interested only in using Python the language with Vue.js, you can trybrythonand thebrython vue demoThere are projects that try to help integrating Vue.js with different Python web frameworks. The goal is different: Vuejs-python makes python and vue tightly integrated, in a common, reactive model.
Package: vue-js-reverse
VUE JS ReverseVue url handling for Django that doesn’t hurt.OverviewDjango Vue Reverse (a fork of Django Js Reverse) is a small django app that makes url handling of
named urls (https://docs.djangoproject.com/en/dev/topics/http/urls/#naming-url-patterns) in javascript easy and non-annoying..You can retrieve a named url:urls.py:path('company/update/company_id/<int:company_id>/', main.update_company, name='update_company')in javascript like:this.$urls.update_company(12)Result:company/update/company_id/12/Requirementspython 3.6+InstallationInstall usingpip…pip install vue-js-reverse... or clone the project from github.git clone https://github.com/miklagard/vue-js-reverseAdd'vue_js_reverse'to yourINSTALLED_APPSsetting.INSTALLED_APPS = (
    ...
    'vue_js_reverse',
)Add library variables to settings.py file.VUE_PLUGINS_DIR = os.path.join(settings.BASE_DIR, 'vue_frontend', 'src', 'plugins')
VUE_REVERSE_URL_PLUGIN = 'Urls.js'Vue main.jsimport Url from "@/plugins/Url"
 Vue.use(Url)Usage as static fileFirst generate static file by./manage.py vue_js_reverseIf you change some urls or add an app and want to update the reverse.js file,
run the command again.After this add the file to your templateLicenseMIThttps://raw.githubusercontent.com/miklagard/vue-js-reverse/master/LICENSEContactcem.yildiz@ya.ruEnjoy!
Package: vue-lexer
vue-lexerA Vue lexer forPygments(based onjsx-lexer)Installation$pipinstallvue-lexerUsage with SphinxTo use within Sphinx, simply specifyvuefor yourcode-block:.. code-block:: vue

    <template>
      <p>{{ greeting }} World!</p>
    </template>

    <script>
    module.exports = {
      data: function () {
        return {
          greeting: 'Hello'
        }
      }
    }
    </script>

    <style scoped>
    p {
      font-size: 2em;
      text-align: center;
    }
    </style>Usage with mkdocsFirst, you need to create the CSS for the highlighting:$pygmentize-Sdefault-fhtml-a.codehilite>code/pygments.cssThen, add the following to yourmkdocs.yml:markdown_extensions:-codehiliteextra_css:[pygments.css]Now, you can usevuein your code blocks:```vue
<template>
  <p>{{ greeting }} World!</p>
</template>

<script>
module.exports = {
  data: function () {
    return {
      greeting: 'Hello'
    }
  }
}
</script>

<style scoped>
p {
  font-size: 2em;
  text-align: center;
}
</style>
```ExamplesExample 1:Example 2:Example 3:
Package: vuepy
vue.pyuseVue.jswith pure Pythonvue.py provides Python bindings forVue.js.
It usesbrythonto run Python in the browser.Here is a simple example of an vue.py componentfrombrowserimportalertfromvueimportVueComponentclassHelloVuePy(VueComponent):greeting="Hello vue.py"defgreet(self,event):alert(self.greeting)template="""<button @click="greet">click me</button>"""HelloVuePy("#app")Installation$pipinstallvuepyDevelopment StatusThe goal is to provide a solution to write fully-featured Vue applications in pure Python.To get an overview what currently is supported, have a look at theDocumentation.Have a lookhereto see whats planned!See also theLimitationsDocumentationDocumentation for the last release is availablehere.Documentation fo the current master branch can be foundhere.Examples can be foundhere.
These are vue.py versions of theVue.js examplesPerformanceInitial loading times ofvue.pyapps can be very long.
Especially when loading a lot of python files.
Still figuring out how to solve this.Have not done any peformance tests, but havent noticed any issues with performance
as soon as the app was fully loaded.DevelopmentGetting StartedOpen ingitpod.ioGet the code$gitclonehttps://github.com/stefanhoelzl/vue.py.git
$cdvue.pyOptionally you can create avenv$python-mvenvvenv
$sourcevenv/bin/activateInstall required python packages, the chromedriver for selenium and brython$makeenv.upFormat the code$makeformatRun tests$maketests# runs all tets$maketests.unit# runs unit tests$maketests.selenium# runs selenium tests$maketests.cli# runs cli tests$maketestsTEST=cli/test_provider.py::TestRenderIndex::test_defaults# run explicit testRun an example$makerunAPP=examples/tree_view# makes example available on port 5000Clean up your working directory.$makeenv.cleanReset your development environment(clean up, reinstall packages and redownload needed files)$makeenv.down
$makeenv.upPublish a new release$makerelease# bumps minor version number$makereleaseMODE=major# bumps major version number$makereleaseMODE=patch# bumps patch numberContributingseeCONTRIBUTINGLicenseThis project is licensed under the MIT License - see theLICENSEfile for details
Package: vuer
Vuer: Modern High-Performance Visualization for AI & Robotics in VRpip install vuer⬝  
visithttps://docs.vuer.aifor documentationVuer is a light-weight visualization toolkit for interacting with dynamic 3D and robotics data. It is
VR and AR ready, and can be run on mobile devices.Our features include:light-weight and performantVR and AR readyHackable and extensibleOpen source, licensed under MITInstallationYou can installvuerwithpip:pipinstall-U'vuer[all]'Here is an example that loads a URDF file and displays it in the browser. For a more comprehensive list of examples, please refer to
theexamplespage.fromvuerimportVuer,VuerSessionfromvuer.schemasimportDefaultScene,Urdfapp=Vuer()@app.spawn(start=True)asyncdefmain(session:VuerSession):app.set@DefaultScene(Urdf("assets/urdf/robotiq.urdf"),)whileTrue:awaitsession.sleep(0.1)To get a quick overview of what you can do withvuer, check out the following:take a look at the example galleryhereor try to take a look at this demohereFor a comprehensive list of visualization components, please refer to
theAPI documentation on Components.For a comprehensive list of data types, please refer to theAPI documentation on Data Types.Now, to run the examples, first download the example datasets.Each subdirectory in theassetsdirectory contains aMakefile. Run themakecommand in each subdirectory to download the datasets. For
example:cdassets/static_3d
makeThen run the examplescdvuer/examples/vuer
python01_trimesh.pyContributing to Documentation and FeaturesDocumentation is a crucial part of thevuerecosystem. To contribute to documentation and usage examples, simply:pipinstall-e'.[dev]'makedocsThis should fire up an http server at the port8888, and you can view the documentation athttp://localhost:8888.About UsVuer is built by researchers at MIT and UCSD in fields including robotics, computer vision, and computer graphics.
Package: vui
vuivui is a cross-platform GUI framwork, built on top of Pyglet. It is currently
in early stage of development. The aim is to build a simple pythonic API that
could be used to build UI apps and games.The framework is built around the hierarchy of UI elements represented by
classes inheriting fromView. A view class can be attached to a (single)Paneobject.Paneis a simple class representing a rectangular area
in the window. This class also plays the role of host for mouse events.Some of the views can contain other views. Such views are called "layouts".
A layout class is aViewthat contains the logic of subdiving its pane into
panes for its children.Various UI classes are glued together withObservablevalues and attributes.
Functions and methods can be registed as listeners to an observable value. These
listeners are called whenever the value is changed. Most attributes of UI values
are observable, including pane dimentions, mouse position and so on.In addition toObservablevui makes use ofeventsmodule forked from Pyglet
events. As a rule, whenever an event can be thought about as changes of some
value, it should be represented asObservable. But some events likeon_drawdon't fit this model and are represented as events.
Package: vukomir-statuspageio
python-statuspageioStatusPage.oi  API V1 library client for Python. Based on the documentaion fromhttps://doers.statuspage.io/api/v1/Provides most of the funcitonality for thehttp://statuspage.ioapi's via handy python code.InstallationStatuspageio package can be installed either via pip:.. code:: bash$ pip install --upgrade statuspageioYou can install from the source code as well. First clone the repo and
then execute:.. code:: bash$ python setup.py installAfter installing, importstatuspageiopackage:.. code:: pythonimport statuspageioUsage.. code:: pythonimport statuspageio

# Then we instantiate a client (as shown below)Build a client**Using this api without authentication gives an error**

.. code:: python

    client = statuspageio.Client(api_key='<YOUR_PERSONAL_API_KEY>', page_id=<YOUR_PERSONAL_PAGE_ID')
or

.. code:: python

    client = statuspageio.Client(api_key='<YOUR_PERSONAL_API_KEY>', page_id=<YOUR_PERSONAL_PAGE_ID',organization_id=<YOUR_PERSONAL_ORGANIZATION_ID)


Client OptionsThe following options are available while instantiating a client:api_key: Personal API Keypage_id: Personal page idorganization_id: Personal organization id, used for managing users.base_url: Base url for the apiuser_agent: Default user-agent for all requeststimeout: Request timeoutverbose: Verbose/debug modeArchitectureThe library follows few architectural principles you should understand
before digging deeper. 1. Interactions with resources are done via
service objects. 2. Service objects are exposed as properties on client
instances. 3. Service objects expose resource-oriented actions. 4.
Actions return dictionaries that support attribute-style access, a la
JavaScript (thanks to Bunch and it's form Munch).

For example, to interact with components API you will use
``statuspageio.ComponentsService``, which you can get if you call:

.. code:: python

    client = statuspageio.Client(api_key='<YOUR_PERSONAL_API_KEY>', page_id=<YOUR_PERSONAL_PAGE_ID')
    client.components # statuspageio.ComponentsService

To retrieve list of resources and use filtering you will call ``#list``
method:

.. code:: python

    client = statuspageio.Client(api_key='<YOUR_PERSONAL_API_KEY>', page_id=<YOUR_PERSONAL_PAGE_ID')
    client.components.list() # list(dict|Munch)



Resources and actions
---------------------

Documentation for every action can be found in ``statuspageio/services.py``
file.


Tests
-----

Sorry. These need to be written. 


Thanks
------

Thank you to the BaseCRM development team who created the majority of the code for this project. 
We forked the code as the aritectural style worked really well for this project. 
Please see https://github.com/basecrm/basecrm-python for more details

Thank you so much!

License
-------

MIT

Bug Reports
-----------

Report `here <https://github.com/vukomir/python-statuspageio/issues>`__.