Saravanan666/pypi-org huggingface dataset:
Package: pyautoweka
pyautoweka==========Description-----------pyautoweka is a python wrapper for [Auto-WEKA](http://www.cs.ubc.ca/labs/beta/Projects/autoweka/), a Java application for algorithm selection and hyperparameter optimizations, that is build on [WEKA](http://www.cs.waikato.ac.nz/ml/weka/).Installation------------Download, go to the project sources and install:```git clone git@github.com:tdomhan/pyautoweka.gitcd pyautowekapython setup.py install```Running an experiment--------------------AutoWeka for python.```pythonimport pyautoweka#Create an experimentexperiment = pyautoweka.Experiment(tuner_timeout=9000)````tuner_timeout` is the time the optimization will run in seconds. So e.g. 9000 seconds = 2.5 hours. The longer you run the optimization, the better of course. (Note that the `experiment` object has an interface similar to sklearn classifiers.)First we need to load some data. Let's for example the the famous [Iris dataset](http://archive.ics.uci.edu/ml/datasets/Iris). Download it using [this link](http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data).Let's load it into python:```python#load the data:import numpy as npimport randomX = np.loadtxt("iris.data", delimiter=",", usecols=range(4))y = np.loadtxt("iris.data", delimiter=",", usecols=[4], dtype="object")#shuffle the data:indices = range(len(X))random.shuffle(indices)X = X[indices]y = y[indices]#split into train and test set:X_train = X[0:100]y_train = y[0:100]X_test = X[100:]y_test = y[100:]#now we can fit a model:experiment.fit(X_train, y_train)#and predict the labels of the held out data:y_predict = experiment.predict(X_test)#Let's check what accuracy we get:num_correct = sum([1 for predicted, correct in zip(y_predict, y_test) if predicted == correct])print "Accuracy: %f" % float(num_correct) / len(y_test)```This should give you an accuracy in the high 90%s.Advanced: Selecting specific classifiers----------------------------------------When you don't set a specific classifier all available classifiers will be tried. You have the option to limit the search to certain classifiers as follows:First of all let's see what classifiers are available:```pythonimport pyautowekaprint pyautoweka.AVAILABLE_CLASSIFIERS```Now let's say we want to just use the Simple Logistic classifier:```pythonexperiment.add_classfier("weka.classifiers.functions.SimpleLogistic")```Advanced: files created-----------------------When you create a new experiment theres a bunch of files that will be generated before and during the run of AutoWeka. For each experiment there will be a new folder within in the `experiments` folder. The folder will have the name of the experiment, if it was specified in the constructor. Each time you fit data a tempraroy arff file will be created that holds all the data in it. This file will be delete after the `fit` call.
Package: pyaux
Personal collection of helpers and often-useful snippets for PythonInstall the latest version withpip install -U “git+https://gitlab.com/hoverhell/pyaux.git#egg=pyaux”Contains:window: iterator over a ‘window’ of N adjacent elementsdotdict: attr→item dict subclass (e.g. ford.keyinstead ofd[‘key’])DebugPlug: recursive duck-object for debug and testing
purposesrepr_call: convenient syntactically-appropriate representation of
call arguments (also used in DebugPlug)fxrange,frange,dxrange,drange:xrange()/range()equivalents for float (without error accumulation) and Decimaldict_fget,dict_fsetdefault: versions ofdict.getanddict.setdefaultwith lazy-computation of the default valuesplit_list: simple one-pass splitting of list into two by a conditionuse_cdecimal: forced instance-wide use (by monkey-hack) ofcdecimalinstead ofdecimal(for performance)use_exc_ipdb: set unhandled exception handler to runipdb.pm()use_exc_log: set unhandled exception handler to log (bylogging) the
exception and the stack trace including (when possible) the local
variables.use_colorer: monkey-patchloggingfor colored loggingobj2dict: recursive converter of tree-structure of classes into a
tree-structure of dicts, e.g. for pretty-printing the resultmk_logging_property: make a property that debug-logs the value and
caller info when setSome other things that are too minor to be listed here.Also, in separate submodules:psql: helpers for saving Django ORM objects into an SQL ‘COPY’-like
file and loading it in one SQL command (for high-performance loading of
large amounts of data into the database)lzmah: lzma compress (as function and as an executable file); also
provides a functionunjsllzmato stream-read (json) lines from a
pylzma-compressed filelzcat: lzcat for pylzma-specific format (as function and as an
executale file)runlib: various things for runscripts:init_logging: logging.basicConfig with useful defaults (for
development runscripts).sigeventer: list-based signal handler for SIGINT and SIGTERM (for
appending handler functions, similarly toatexit)
Package: py-auxo-bee
#Beebeeis an all-in-one python framework for simplifying micro service program development.ComponentsConfig- Manage configuration for yml, yaml & jsonRPC- Lightweight and high performaceSerializableProtoBufjsonhttp to be continuedService Discovery - Automatic registration and name resolution with service discoveryetcd3consulLoad Balancing - Smart client side load balancing of services built on discoveryRandomBalancerRoundRobbinBalancerWeb- Web server with a variety of advanced features, to be continuedDatabasePsd - A lightweight, fluent SQL data access and ORM libraryMongoDB - A useful wrapper formongoRedis - A useful wrapper forredis,redis-py-clusterUtility- Some useful utility packages..debugi18nguidconstmapobjectpool
Package: pyav
pyavpyav implements bindings for theffmpeglibraries. We aim to provide all of the power and control of the underlying library, but manage the gritty details as much as possible.pyav is for direct and precise access to your media via containers, streams, packets, codecs, and frames. It exposes a few transformations of that data, and helps you get your data to/from other packages (e.g. Numpy and Pillow).This power does come with some responsibility as working with media is horrendously complicated and pyav can't make all the best decisions for you. If theffmpegcli does the job without you bending over backwards, use it. pyav is much more complicated than the standaloneffmpegprogram.InstallingJust run:pip install pyavRunning the command should install the binary wheel provided. Due to the complexity of the dependencies, pyav is not easy to install from source. If you want to try your luck anyway, you can run:pip install pyav --no-binary pyavAnd if you want to build the absolute latest (POSIX only):gitclonehttps://github.com/WyattBlue/pyav.gitcdpyavsourcescripts/activate.sh
pipinstall-U-rtests/requirements.txt
./scripts/build-deps
make
deactivate
pipinstall.Aboutpyav is a friendly fork ofPyAVmade by a PyAV maintainer. pyav offers bleeding-edge features in exchange for requiring more up to date Python and FFmpeg versions.
Package: pyav2
pyav2Introducepyav+typing hint⭐️ 🌟 ✨ ⚡️ ☄️ 💥InstallationPackage is uploaded on PyPI.You can install it with pip:pipinstallpyav2RequirementsPython -- one of the following:CPython : 3.8 and newer ✅PyPy : Software compatibility not yet tested ❓
Package: py-ava
https://git.sr.ht/~qeef/py-avarepository contains Automated Vehicle
Architecture packages written in Python3 with object-oriented paradigm.pdcpackage contains two modules:dpmodule with classes for perception.bqsmodule with classes for decision and control.To contribute, please::git config format.subjectPrefix "PATCH py-ava"
git config sendemail.to "~qeef/public-inbox@lists.sr.ht"
Package: pyavaccess
pyavaccessPython libary for interfacing with AV Access devices over serial. Designed for use withHome Assistant.Supported DevicesAv Access 4×2 4K HDMI Matrix (4kmx42-h2a)Although this library was created for and tested with the 4kmx42-h2a, it was written so that it could be easily expanded for use with any AV Access device.Have a different device?If you're a developer - please consider contributing to this project :)If you're not a developer - open an issue with the model and features of your device and I'll see what I can doUsagefrompyavaccessimportHDMIMatrixSerial# Interface with a "4kmx42-h2a" device over serial at "/dev/ttyUSB0"av=HDMIMatrixSerial("/dev/ttyUSB0","4KMX42-H2A")# Print current versionprint(av.getVer())# Get a map of active input for each output {out: in, ...}outputMap=av.getMappings()# For each output, print the input mapped to itforoutput,inputinoutputMap.items():print("Output{}is mapped to input{}".format(output,input))# Set the input for output 1 to input 4av.mapOutput(1,4)# Check that the mapping was successfulassertav.getMapping(1)[1]==4
Package: pyavagen
Generation of customizable avatars.Requirements:Python 3.3+PillowInstallation:pip install pyavagenAvatar typesFor avatar generation using theAvatarclass.Arguments:kwargs- keyword arguments that are passed to specified avatar_class.avatar_type- avatar type that will be generates an image.Types:pyavagen.SQUARE_AVATARor'square'pyavagen.CHAR_AVATARor'char'pyavagen.CHAR_SQUARE_AVATARor'char_square'Avatar types description is given below.Char avatarDraws a character on background with single color.Usage:importpyavagenavatar=pyavagen.Avatar(pyavagen.CHAR_AVATAR,size=500,string="Paul")avatar.generate().save('avatar.png')Arguments:size- size of output image. The integer type.string- first chars of two first words that separated whitespaces.
For example from string ‘John Paul’ draws “JP”.
If passed an one word then draws a first char of this word.
For example from string ‘John’ draws “J”. The string type.font- TrueType or OpenType font file. Path to font file. Default
Comfortaa-Regular.background_color- background color. If not passed that a will be
a random color fromcolor_list.font_size- size of font. The integer type. Has default value.font_color- color of font. The string type. Default white.font_outline- Outline of character. Default false.color_list- list of colors from which will be generating colors
for background. Defaultpyavagen.COLOR_LIST_FLAT.Square avatarDraws squares with different colors.Usage:importpyavagenavatar=pyavagen.Avatar(pyavagen.SQUARE_AVATAR,size=500)avatar.generate().save('avatar.png')Arguments:size- size of output image. The integer type.squares_on_axis- number of squares on axis. The integer type.
Default random value from 3 to 4.blur_radius- blur radius. UsedPIL.ImageFilter.GaussianBlur.The integer type. Default 1.rotate- image rotate. The integer type. Default random rotation.border_size- border size of square. The integer type. Default 0.border_color- border color of squares. The string type. Default
black.color_list- list of colors from which will be generating colors
for squares. By default a set of flat colors
(pyavagen.COLOR_LIST_FLAT). Ifcolor_listpassed as an empty
list then will be generation a random color. There is also list of
colors in material style -pyavagen.COLOR_LIST_MATERIAL.Char square avatarDraws a character on background with squares with different colors.Usage:importpyavagenavatar=pyavagen.Avatar(pyavagen.CHAR_SQUARE_AVATAR,size=500,string="Jack")avatar.generate().save('avatar.png')Arguments:The same arguments as for Square avatar and Char avatar.TestingExecutetoxfrom the project root.
Package: pyavalanche
Todo:
samples
docsThis package implements Python OO API for Avalanche.FunctionalityThe current version supports the following test flow:Load configuration -> Get/Set attributes -> Start/Stop traffic -> Get statistics.Supported operations:Basic operations - get/set attributes, get/create children.Connect - to chassisLoad configuration - load configuration (spf), select test, reserve ports and assign ports to interfacesTest - start, stop, wait, get statusStatistics - subscribe, read views, unsubscribeSave configurationDisconnectPrerequisiteAvalanche application installed.
Tcllib package installed.Installationpip instsll pyavalancheGetting startedUnder avalanche.test.avl_samples you will find some basic samples.
See inside for more info.Documentationhttp://pyavalanche.readthedocs.io/en/latest/Related workpytestcenter, pyixloadContactFeel free to contact me with any question or feature request atyoram@ignissoft.com
Package: py-avataaars
py-avataaars - Python component for AvataaarsPython port ofhttps://github.com/fangpenlin/avataaarsThe core React component forAvataaars Generatordeveloped byFang-Pen Lin, based on the Sketch libraryAvataaarsdesigned byPablo Stanley.FeaturesSVG basedLight weightEasy to useInstallpipinstallpy-avataaarsUsageBasic usage:frompy_avataaarsimportPyAvataaaravatar=PyAvataaar()avatar.render_png_file('<output_file.png>')Specify each part of avatar:importpy_avataaarsaspaavatar=pa.PyAvataaar(style=pa.AvatarStyle.CIRCLE,skin_color=pa.SkinColor.LIGHT,hair_color=pa.HairColor.BROWN,facial_hair_type=pa.FacialHairType.DEFAULT,facial_hair_color=pa.HairColor.BLACK,top_type=pa.TopType.SHORT_HAIR_SHORT_FLAT,hat_color=pa.Color.BLACK,mouth_type=pa.MouthType.SMILE,eye_type=pa.EyesType.DEFAULT,eyebrow_type=pa.EyebrowType.DEFAULT,nose_type=pa.NoseType.DEFAULT,accessories_type=pa.AccessoriesType.DEFAULT,clothe_type=pa.ClotheType.GRAPHIC_SHIRT,clothe_color=pa.Color.HEATHER,clothe_graphic_type=pa.ClotheGraphicType.BAT,)avatar.render_png_file('<output_file.png>')
Package: py-avataaars-no-png
py-avataaars - Python component for AvataaarsFORK OFhttps://github.com/kebu/py-avataaarsChangesSwitched from setup.py to PoetryRemoved svg2png-dependency ->No PNG-supportOriginal READMEPython port ofhttps://github.com/fangpenlin/avataaarsThe core React component forAvataaars Generatordeveloped byFang-Pen Lin, based on the Sketch libraryAvataaarsdesigned byPablo Stanley.FeaturesSVG basedLight weightEasy to useInstallpipinstallpy-avataaarsUsageBasic usage:frompy_avataaarsimportPyAvataaaravatar=PyAvataaar()avatar_svg=avatar.render_svg()Specify each part of avatar:importpy_avataaarsaspaavatar=pa.PyAvataaar(style=pa.AvatarStyle.CIRCLE,skin_color=pa.SkinColor.LIGHT,hair_color=pa.HairColor.BROWN,facial_hair_type=pa.FacialHairType.DEFAULT,facial_hair_color=pa.HairColor.BLACK,top_type=pa.TopType.SHORT_HAIR_SHORT_FLAT,hat_color=pa.Color.BLACK,mouth_type=pa.MouthType.SMILE,eye_type=pa.EyesType.DEFAULT,eyebrow_type=pa.EyebrowType.DEFAULT,nose_type=pa.NoseType.DEFAULT,accessories_type=pa.AccessoriesType.DEFAULT,clothe_type=pa.ClotheType.GRAPHIC_SHIRT,clothe_color=pa.Color.HEATHER,clothe_graphic_type=pa.ClotheGraphicType.BAT,)avatar_svg=avatar.render_svg()
Package: pyavatar
pyavatarCreate default user avatars from a given stringThis package creates simple user avatars that can be used in web-applications.Avatars are generated from the first letter of a given string input.InstallationPyavatar is on Pypi so all you need is:pip install pyavatarUsageGenerate an avatar>>>frompyavatarimportPyAvatar>>>>>>avatar=PyAvatar("smallwat3r",size=250)# use a specific size>>>avatar=PyAvatar("smallwat3r",capitalize=False)# without capitalization>>>avatar=PyAvatar("smallwat3r",color=(40,176,200))# use a specific color>>>avatar=PyAvatar("smallwat3r",fontpath="/Users/me/fonts/myfont.ttf")# use a specific fontChange the avatar color>>>avatar.color(191,91,81)>>>avatar.change_color()# random color>>>avatar.color(203,22,126)>>>avatar.change_color("#28b0c8")# using an hex color code>>>avatar.color'#28b0c8'Save the avatar as a base64 image>>>image=avatar.base64_image("jpeg")'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBg ...'You can then render it in an html tag with Jinja or another template engine<imgsrc="{{ image }}"alt="My avatar"/>Or save it as a bytes array>>>avatar.stream("png")b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\xfa\x00\x00...'Or save it as a file locally>>>importos>>>avatar.save(f"{os.getcwd()}/me.png")DevelopmentRequirementsMake sure you're using a version of Python >= 3.10Create a virtual environment and install the dependenciesmake venv depsSanity checksUnit testsmake testsMypymake mypyRuffmake ruffRun all the abovemake ciCode formattingWe're usingYAPFto format the codemake yapfRelease to Pypimake release
Package: pyavb
pyavbA python module for reading and writing Avid Bin Files (AVB) files.NoticeThis project is in no way affiliated, nor endorsed in any way with Avid, and their name and all product names are registered brand names and trademarks that belong to them.RequirementsPython >= 2.7InstallationYou can install pyavb via:pip install pyavbor clone the latest development git master:git clone https://github.com/markreidvfx/pyavb
cd pyavb
python setup.py installDocumentationDocumentation is available onRead the Docs.
Package: pyavdesk
Dr.Web pyavdesk(python-avdesk) is a Python module, wrappingDr.Web dwavdapiC library to introduce
simple yet powerful interface to manipulate Dr.Web AV-Desk server resources from within your
Python code, making integration of third-party applications with AV-Desk as easy as possible.https://github.com/DoctorWebLtd/pyavdeskRequirementsPython 2.6+Dr.Web AV-Desk -http://ru.av-desk.com/support/demo/?lng=enDr.Webdwavdapilibrary -http://download.geo.drweb.com/pub/drweb/avd/libs/libdwavdapi/Python setuptools (to install pyavdesk package using setup.py)InstallationExecute from command line:> python setup.py installNote: this command requires python-setuptools package to be installed in advance.DocumentationAPI documentation is available athttps://drweb-pyavdesk.readthedocs.org/.Dr.Web pyavdesk uses python-sphinx for API documentation builds:
usemake <build_format_name>indocs/directory to build documentation from sources.CopyrightCopyright (c) 2003-2013, Doctor Web, Ltd.Dr.Web pyavdesk is distributed under the license available from LICENSE file provided
with the source code.http://www.drweb.comhttp://www.av-desk.com
Package: pyavia
PyAviaPyAviais a collection of modules useful for common tasks in aerospace
engineering or engineering in general.The current version is0.0.3.Important points:Development is intended to be organic.Modules presently included were either previously developed during my day-to-day
work as an engineer, or otherwise just out of curiosity.  If something
seems like it might be useful to other people, I will try to include it.I don't intend on including anything that is particularly arcane, buggy,
hard to use or not for the public domain.WarningCAVEAT COMPUTOR- These modules are provided "as is", without warranty
of any kind.  They are intended to be read and/or used by people trained
in engineering and scientific methods who know how to verify results and
who can recognise incorrect values when they see them...which will
happen frequently.InstallationNumPy may need to be installed prior to installing PyAvia (because I may
not have setuptools completely on my side),see this link.Once NumPy is installed, install PyAvia using the typical pip installation
methods, for example:Using a shell with pip directly and root access:$pipinstallpyaviaUsing a windows prompt as a user only:C:\> py -m pip install --user pyaviaDocumentationDocumentation can be found atReadTheDocs.Source CodeThe source code is available in theGithub repository.LicensePyAvia is provided free of charge for use under the conditions of theMIT license.See thelicense filefor more details.Copyright 2020 Â© Eric J. Whitney
Package: pyaviation
Py AviationThe "aviation" project regroups a set of formulas and general principles for aviation for Python.Getting startedTo start using the module, you can start by creating a aircraft model from one of the base aircraft manufacturers.from pyaviation.aircraft import Cessna

airplane = Cessna()This creates a blank airplane model on which you can call a variety of functions.Python aviation comes however with a set of built in aircraft models that you can use.from pyaviation.models  import A320

aircraft = A320()The flight mixin and basic calculationsThe flight mixin regroups all the main definitions for calculating items related to flight.Provided you've constructed an airplane like above, you can do the following.Calculating basic speedairplane.calculate_speed(50, 2)

>>Calculting distanceairplane.calculate_distance( , )

>>Calculate durationairplane.calculate_duration( , )

>>Calculate arrival timeairplane.calculate_arrival_time( , )

>>Calculate ground speedairplane.ground_speed( , )

>>True air speedairplane.true_air_speed( , )

>>Calculate density altituteairplane.density_altitude( , )

>>Calculate fuelCalculates the fuel consumed during a flight of x hours and minutes and eventually the remaining minutes left to fly with the fuel left.airplane.fuel( , )

>>Calculate consumption rateairplane.fuel_consumption_rate( , )

>>Calculate ground gradientairplane.ground_gradient( , )

>>Calculate obstacle clearanceairplane.calculate_obstacle_clearance( , )

>>Calculate distance to horizonairplane.distance_to_horizon( , )

>>Calculate Needed fuelairplane.needed_fuel( , )

>>Specific aircraft calculationsConsidering that each new class you create using theBaseAircraftclass (exactly like we did in the above examples), each newly created class will provide additional definitions that will take into consideration the specific characteristics of each aircraft.Safety factorairplane.safety_factor( , )

>>Net performanceairplane.net_performance( , )

>>Gross performanceairplane.gross_performance( , )

>>Gradient of climbairplane.gradient_of_climb( , )

>>Ground gradientairplane.ground_gradient( , )

>>Maximum payloadairplane.maximum_payload( , )

>>Creating a new aircraft modelCreating a new model is very simple. Just subclass theAirplaneclass in order to create a new manufacturer for example.from pyaviation.aircraft import Aircraft

class CustomManufacturer(Aircraft):
    manufacturer = "Custom"

class MyAircraft(CustomManufacturer):
    version = "eco-xxx"
    speed = {
        "cruise": 456,
        "max": 567
    }
    max_rang = 5678
    weight = {
        "taxi": 73900,
        "takeoff": 73500,
        "landing": 64500
    }
    fuel = {
        "max": 23859
    }
    passengers = 150
    ceiling = {
        "range": [39100, 41000]
    }

aircraft = MyAircraft()
Package: pyaviso
AvisoAviso is a software developed by ECMWF that allows the notification oftime-critical eventsacross HPC and Cloud systems in
order to enable workflows among multiple domains.It allows users to:Define events that require notificationDefine triggers to be executed once a notification is receivedSend and receive notificationsThis enables the creation of automatic workflows, timely triggered as events are notified.The documentation can be found athttps://pyaviso.readthedocs.io/Examples demonstrating the usage of aviso for ECMWF notifications can be found athttps://github.com/ecmwf/aviso-examples
Package: pyavl
This small C package is comprised of an independent set of
routines dedicated to manipulating AVL trees (files avl.c, avl.h), and of
an extension module for Python that builds upon it (file avlmodule.c) to
provide objects of type ‘avl_tree’ in Python, which can behave as sorted
containers or sequential lists.  For example one can take slices of trees
with the usual syntax.  Unlike collectionsmodule.c, avlmodule.c contains
only bindings to the underlying implementation.
Package: pyavl3
pyavl3A python dictionary alternative implemented with an AVL Tree.Quick Startpipinstallpyavl3frompyavl3importAVLTreea=AVLTree()a[1]="Hello"a[2]="world!"print(", ".join(a.values()))Why?Python dictionaries are implemented on hashmaps. Hashmaps, besides being awesome, are a balancing
act between efficiency and memory utilization. Python's builtin algorithm is solid and probably the
correct choice 99 times out 100. Not really a supprise. But, hashmaps suffers from the need to
resize and resizing is pretty expensive. For those few cases where resizing large in-memory blocks
of sequentional memory is not going to work, AVLTrees might be a better option. Oh, and AVLTrees are
effectivly sorted. So, iterators are deterministic and always in order.This table compairs the runtime characteristics of Hashtables and AVLTreesHashtableHashtable(worst case)AVLTreeAVLTree(worst case)SpaceO(n)O(n)O(n)O(n)SearchO(1)O(n)O(logn)O(logn)InsertO(1)O(n)O(logn)O(logn)DeleteO(1)O(n)O(logn)O(logn)ResizeO(n)O(n)N/AN/A