Saravanan666/pypi-org huggingface dataset:
Package: happy
Quickly set up and tear down Heroku apps!Quickly startingAdd anapp.json manifestthat looks kinda like this:{"name":"My App Thing","repository":"https://github.com/helloitsme/thingy","env":{"FROBULATION_LIMIT":{"description":"Maximum frobulations per lunar cycle.","value":"7"}},"addons":["pusher"]}Push that to your thing’smasterbranch on GitHub so Heroku can find it.Log in with theHeroku toolbelt, then do this:$ pip install happy
$ happy up butt-man-123
Creating app... butt-man-123
Building... done
It's up! :) https://butt-man-123.herokuapp.comThat’s it! You made a temporary app with all the fixins, which you can
use to continuously integrate or whatever you want to do.Then, you can get rid of it like:$ happy down butt-man-123
Are you sure you want to delete butt-man-123? [y/N]: y
Destroying app butt-man-123... done
It's down. :(CommandsupUsage:happy up [OPTIONS] [APP_NAME]Brings up a Heroku app.The app name is stored in a file called.happyin the working directory so
happy can find it later.APP_NAME(optional) Name of the Heroku app to create. If this is not given, one is
chosen for you by the Heroku API.--auth-token(optional) Heroku API auth token. If this is not given, happy assumes you’re
logged in through Heroku CLI, i.e. your token is stored in yournetrcfile.--env(optional) Environment variable overrides, e.g.--envKEY=value. For
multiple variables, this option can be passed more than once. Variable names
MUST match one of the names in theenvsection of yourapp.json, or
the build will fail with aninvalid app.jsonmessage.--tarball-url(optional) URL of the tarball containing app.json. If this is not given,
happy tries to infer it from anapp.jsonfile in the current directory.downUsage:happy down [OPTIONS] [APP_NAME]Brings down a Heroku app.APP_NAME(optional) Name of the Heroku app to delete. If this is not given, the app
name is read from a file called.happyin the working directory.--auth-token(optional) Heroku API auth token. If this is not given, happy assumes you’re
logged in through Heroku CLI, i.e. your token is stored in yournetrcfile.--force(optional) Suppress the delete confirmation prompt. Useful for automation!Running the testsInstalltoxwithpip install tox.Run the tests withtox.
Package: happyaccidentsapi
HappyAccidentsAPIAt the moment, HappyAccidents has not provided an official API and the library is built on the basis of the client API. Because of this, you may find bugs and shortcomings, if this happened, please provide a report inIssues.Quick exampleimportasynciofromhappyaccidentsapiimportClientAPIfromhappyaccidentsapi.modelsimportCreateInferenceParamsasyncdefmain():api=ClientAPI(token="...")model=(awaitapi.fetch_metadata_items("Stable Diffusion v1.5")).first()inference_params=CreateInferenceParams(modelId=model.id,prompt="Beautiful girl on the beach",numImagesToGenerate=5,)inference=awaitapi.create_inference(inference_params)# <InferenceHistoricalResult ...>forimageininference.images:# [<ImageRecord ...>, ...]print(image.get_url())# https://https://ik.imagekit.io/.../result-4.pngawaitimage.save(f"./images/{image.id}-{image.filename}")if__name__=="__main__":asyncio.run(main())NOTE: It is not advised to leave your token directly in your code, as it allows anyone with it to access your account. If you intend to make your code public you should store it securely.LinksRepositoryDocumentationExamplesHow to get token?
Package: happybase-mock
A mocking library forHappyBase.InstallingHBaseis not easy. RunningHBasealso costs high system resource.
This library simulatesHappyBaseAPI in local memory, so you don’t have to
set upHBase. This is handy if you want to do fast in-memory testing.InstallationTo install HappyBase-mock, just do:pip install happybase-mockUsageThe API and package structure of HappyBase-mock is a mimic ofHappyBase. They
are almost identical, so you can use it like you normally would do inHappyBase.For example, you can replacehappybasepackage withhappybase_mock.
Then all of the operations will be performed in memory:import happybase_mock as happybase

pool = happybase.ConnectionPool(host='localhost', table_prefix='app')
with pool.connection() as conn:
    table = conn.table('table_name')
    table.put('rowkey', {'d:data': 'value'})TIP: You can also useMocklibrary to help you patchHappyBaseon runtime.ContributeRunning TestsInstall test requirements:pip install -r requirements-test.txtThen run the test:py.test
Package: happybase-sql
happybase-sqlA (mostly) drop-in replacement for (happybase)[https://happybase.readthedocs.io/en/latest/] that uses an SQL backend instead of HBase.** Why would I want to use this? **This project came about when I was working on a legacy project that used a HBase datastore. The HBase cluster became problematic, suffering from performance issues and was expensive to run. After wrestling with HBase for too long, I decided to migrate the data to SQL and wrote this replacement for the happybase library. It's mostly API compatible, so only needed a few minor changes to the code base to swap it in for happybase and thus avoid a lot of time-consuming refactoring. Depending how capital-BBig Datayour requirements are, you might find (like I did) that the scale of HBase actually wasn't required, and an SQL DB was plenty big enough, much simpler to administer and a lot cheaper.Getting startedYou'll need to create a table in your SQL database for each of your HBase tables.Note: currently only Postgres is supportedHere's an example table definition, just replacemy_table_namewith the name of your table. Note the two indices, one for key uniqueness (which is the equivalent of the HBase row key), and thevarchar_pattern_opsindex. This is required to allow efficient prefix queries, a feature of HBase key lookups and scans. The data is stored in a JSONB column, where the keys of that JSON data are the HBase column names (e.g. 'cf:col').CREATETABLEpublic."my_table_name"("key"varcharNOTNULL,"data"jsonbNOTNULL);CREATEUNIQUEINDEXmy_table_name_key_idxONpublic.my_table_nameUSINGbtree(key);CREATEINDEXmy_table_name_key_ops_idxONpublic.my_table_nameUSINGbtree(keyvarchar_pattern_ops);Install the happybase-sql package into your project:pipinstallhappybase-sqlCreate aConnectionorConnectionPool. Note that thehostargument is slightly different tohappybase, it now refers to thefullSQL database URL (including port). The port argument is ignored.fromhappybase_sqlimportConnectionPoolconnection_pool=ConnectionPool(size=3,host='postgresql://localhost:5432/hbase')withconnection_pool.connection()asconnection:table=connection.table('my_table_name')table.put(row='abcd',data={'cf:col1':'some data','cf:col2':'some more data',},)row=table.row('abcd')print(row)
Package: happybuf
happybuf -HappyAppendablePythonBuffersAn abstraction layer for multiple popular serialization formats:Protocol BuffersCap'n ProtoFlatBuffersThis package is an exploration of different serialization formats/libraries
regarding their support of appending (chaining) multiple messages.
This can be useful when storing serialized data in a binary file that is
supposed to grow over time.While developing, those general resources for using the different backend libs with Python are useful:Protocol Buffers:https://googleapis.dev/python/protobuf/latest/https://developers.google.com/protocol-buffers/docs/reference/python-generatedhttps://github.com/protocolbuffers/protobuf/tree/master/pythonhttps://developers.google.com/protocol-buffers/docs/pythontutorialCap'n Proto:https://github.com/capnproto/pycapnphttps://capnproto.github.io/pycapnp/FlatBuffers:https://google.github.io/flatbuffers/flatbuffers_guide_tutorial.html-> selectPythonhttps://google.github.io/flatbuffers/flatbuffers_guide_use_python.htmlhttps://google.github.io/flatbuffers/flatbuffers_support.htmlhttps://github.com/google/flatbuffers/blob/master/samples/sample_binary.pySome more Python libs I found interesting while doing research
(not necessarily related to this project):protobuf-serializationserpy
Package: happycalc
—Name: happycalcVersion: 0.0.1Description: happycalc is a Python package made for performing essential math calculations for everyday use.Supported Actions:AdditionMultiplicationSubtractionDivisionnth root calculationMemory resetPrint out memory—
How to install this package:
1. installing via terminal -pip install happycalcinstalling via IDE -%pip install happycalc—
How it works:from calculator.calculator import Calculator as calcnew_obj = calc.Calculator()  # New object is created.new_obj.add(15) # Returns 15.0new_obj.subtract(5) # Returns 10.0new_obj.multiply(20) # Returns 200.0new_obj.divide(2) # Returns 100.0new_obj.n_root(2) # Returns 10.0new_obj.return_memory # Returns 10.0new_obj.memory_reset # Resets memory to 0.0—Keywords: calculator, addition, multiplication, subtraction, division, nth rootThis project is licensed under the terms of the MIT license.
Package: happy-config
Happy ConfigManaging ML experiment configuration with joy.Usedataclassto define the schema for experiment configurations.Load configuration from multiple sources: JSON, YAML, NNI.Annotate fields with search space, and generate NNI search space file using CLI tool.Basic UsageDefine configuration schema withdataclassfromdataclassesimportdataclass@dataclassclassBar:a:strb:str@dataclassclassFoo:x:inty:intbar:BarWrite configuration files{"x":1,"y":1,"bar:a":"1","bar:b":"1"}Note the namespace syntaxbar:awe use in JSON. It is also possible to write:{"x":1,"y":1,"bar":{"a":"1"},"bar:b":"1"}Create aConfigLoaderinstacen from the schema, and load the configurationfromhappy_configimportConfigLoaderloader=ConfigLoader(model=Foo,config="config.json")config:Foo=loader()# Foo(x=1, y=1, bar=Bar(a="1", b="1"))If we save the code inmain.py, we can use command line arguments to specify the configuration file path:pythonmain.py--configconfig.jsonAnd we can overwrite the configurations directly using command line arguments:pythonmain.py--x10--bar:b100We have to use the namespace syntax here.Generating NNI Search Space FileWe embed parameter search spaces in the definition of configuration schema.fromdataclassesimportdataclassfromhappy_configimportConfigLoaderfromhappy_config.typecheckingimportshow_typefromhappy_config.param_tuningimportwith_search_space@dataclassclassBar:s:str@dataclassclassFoo:y:intbar:Barx:float=with_search_space(1.0,space_type='uniform',space_value=[0.0,1.0])@dataclassclassConfig:foo:Fooi:int=with_search_space(0,space_type='choice',space_value=[1,2,3])Save the file inmain.py. And in CLI:python -m happy_config genspace -m main.Config -o search_space.jsonThe outputedsearch_space.jsonfile:{"foo:x":{"_type":"uniform","_value":[0.0,1.0]},"i":{"_type":"choice","_value":[1,2,3]}}
Package: happy-control
Nonlinear Algebraic Approximation of Control SystemsA Python implementation of an algorithm for construction homogeneous
approximations of nonlinear control systems. For description of the algorithm refer to ...InstallationYou can install the package using pippip install happy-controlHow to useThe main part of the package is implemented in a single class called ControlSystem. This class describes a control system and its methods implement the algorithm of approximation of a given system.fromhappy_control.approximation_toolsimportControlSystemGiven a systemyou can initialize it the following way:system=ControlSystem(a,b)whereaandbare corresponding vectors.Note: the vectorsmustbe composed out of sympy symbols or numbers.
For example, consider a system:Then the implementation using the package would be as follows:importsympyassymfromhappy_control.approximation_toolsimportControlSystemx1,t=sym.symbols('x_{1}t')a=sym.Matrix([0,-sym.Rational(1,2)*x1**2-4*t*x1-3*t**2*x1,-x1**2-2*t*x1-3*t**2*x1])b=sym.Matrix([-1,0,0])system=ControlSystem(a,b)Then you have 2 options: you can either approximate this system using nonlinear power moments series or using Fliess series# to approximate using nonlinear power moments algebrasystem.calc_approx_system()# to approximate using Fliess algebrasystem.calc_approx_system(fliess=True)To generate the pdf file you need to do as follows:# to generate pdf for systems which were appoximated using Fliess series# add additional argument fliess=Truesystem.generate_pdf()This will produce a pdf file named 'output.pdf' in your current working directory with all the necessary information of the system and its approximation.To customize filename and directory where the file will be saved use additional parameters# generate pdf in custom directory and custom filename (filename does# not need to include .pdf extension, it will be added automatically, so just provide the name)system.generate_pdf(path="path_to_directory",filename="custom_filename")
Package: happy-couple
happy_coupleScript for create cover of animation from revenge of the nerds movieInfoFor now script works with open-cv. I think of add some features in the future, and tkinter gui as option.Install.. code-block:: pythonpip install happy_coupleUsage.. code-block:: pythonfrom happy_couple import animation

animation(Fale)
# then just press enter, or type some commands. Hardcoded sequence will be executed.

animation(True)
# use specified commands, to create expected animationFake sequence commandsIt can be use, to simulate real coding:- > this is very strange animation

- > start

- > glasses(20, some.glasses())

- > eyes(2, 'big', 'center-left')

- > hair('wavy', 'long')

- > resize_down('right-corner')

- > full_figure('legs', 'hands', 'feets')

- > man_full_figure('head', 'body', 'legs', 'hands', 'feets', 'glasses')

- > hand_up('man')

- > hand_up('woman')

- > walk(men, woman)

- > dance('right-left', 'forward', 'sound'='on')Screen from happy_couple animation.. image:: happy_couple.png
Package: happycowler
HappyCowlerHappyCowler is a crawler and parser for extracting geospatial data fromHappyCow.netthat liberates vegans and vegetarians from having to access the Internet while looking for a restaurant. The script crawls the descriptions and coordinates from the website and generates a GPX or KML file with the extracted information. Currently, the GPX file is tuned forOsmand.The primary reason for this crawler is that HappyCow is impossible to use on a mobile browser. While apps are available, they require the presence of proprietary applications such as Google Play. Furthermore, a payment is also required. Thus it is not possible to obtain the app without sacrificing your privacy. By crawling the database, we obtain an offline file that can be used with a GPS app of your choice, without need for Internet access while on the go.DependenciesThe script works with both Python 2 and 3. It relies onBeautifulSoup4for HTML parsing.UsageOn the command line, the script takes two parameters. The first is a URL for the results page of a city. The second is the name of the GPX or KML file. For example:$ happycowlhttp://www.happycow.net/asia/japan/tokyo/Tokyo_Restaurants.gpxThe type of the file is determined by the extension of the filename. Once the scraping finished, copy the file to your phone where your mapping app can find it. For instance, in Osmand, the contents of the folderosmand/trackscan easily be put on the map.You can also use it as a module. In this case, instantiate the  classHappyCow(city_url, target_file=None, verbose=0). Then you can start crawling by calling thecrawl()method of the class.InstallationThe code is available on PyPI, hence it can be installed by$ pip install happycowlerFor the development version, clone it from git and follow the standard
procedure for installing Python modules from source:$ python setup.py installDisclaimerIt is conceivable that crawling HappyCow is illegal.
Package: happydevelopperfr-flyplanner
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.Description: [![Build Status](https://cloud.drone.io/api/badges/happy-developer-fr/fly-planner/status.svg)](https://cloud.drone.io/happy-developer-fr/fly-planner)Platform: UNKNOWN
Description-Content-Type: text/markdown
Package: happydoc
Happy DocInstall$ pip install happydocRunCheck available templates:$ happydoc template
['report.md', 'devis.md']Generate a document from template:$ happydoc template report.md myreport.mdWhen report is over convert it to PDF:$ happydoc convert myreport.md myreport.pdfReadAll documents are generated from the markdown usingpython-markdownsyntax and extra extensions.https://python-markdown.github.io/extensions/
Package: happy-face
happy_faceTerminal install:pip install happy_faceImport:fromhappy_face.happy_faceimportHappyFaceIntroduction:happy_face was built on many different amazing libraries, mainly face_recognition from Adam Geitgey, dlib and many more. I do not take any accomplishment in doing this, it is just an easy way of implementing face_recognition for people that are starting.The main purpose of happy_face is to show the magic of deep learning to people that are just starting with programming.It has few functions, but it is extremely easy to use, this motivates people that are just starting because in python you do not see visual results until later in the journey, this can sometimes kill the creative energy.Brief Explanation:You just need to create a variable, instantiate it with HappyFace and fill three params:known_person_path_file: is the path to the SINGLE image of the face that you want to be recognized.unknown_images_path_file: here is the path to the FOLDER where you have all the other images that you want to recognize.known_name : The name of the known_person_path_file, this will display Found U! If left empty.IMPORTANT!!! Make sure your files (folders or pictures) DO NOT START WITH A DOT --> . <---, if they do, the application will have troubles to execute, this is because sometimes there are hidden files and they start with a dot. This was taken into consideration so the application runs smoothly, just make sure that your folders and files (images) do NOT start with a dot ---> . <---Sample Code:tiger_woods=HappyFace(known_person_path_file='/Users/Desktop/tiger.png',unknown_images_path_file='/Users/Desktop/unknown_pictures',known_name='Tiger Woods')Functions:display_known_im() -- will display the known_person_path_file imagedetects_known_face() -- will detect the face of the known persondetects_unknown_faces() -- will detect all the faces of the images provided in the unknown_images_path_file folderrecognize_faces() -- Will recognize either the person is you (or whoever you provided) or a strangerSample Code:tiger_woods.display_known_im()#Will display the imagetiger_woods.detects_known_face()#Will detect the face of (in this case) Tiger Woodstiger_woods.detects_unknown_faces()#Will detect all the faces provided of the unknown peopletiger_woods.recognize_faces()--# Will recognize either the person is tiger woods or a strangerEXAMPLE:fromhappy_face.happy_faceimportHappyFace# Instantiate a variable to HappyFace and provide YOUR path file to the image and foldertiger_woods=HappyFace(known_person_path_file='/Users/Desktop/tiger.png',unknown_images_path_file='/Users/Desktop/unknown_pictures',known_name='Tiger Woods')# Executetiger_woods.recognize_faces()OUTPUT:
Package: happyfeat
HappyFeat - Interactive framework for clinical BCI applicationsHappyFeat is a software aiming to to simplify the use of BCI pipelines in clinical settings. More precisely, it is asoftware assitant for extracting and selecting classification features for BCI.It gathers all necessary manipulations and analysis in a single convenient GUI, and automates experimental or analytic parameters. The resulting workflow allows for effortlessly selecting the best features, helping to achieve good BCI performance in time-constrained environments. Alternative features based on Functional Connectivity can be used and compared or combined with Power Spectral Density, allowing a network-oriented approach.It consists of Qt-based GUIs and Python toolboxes, allowing to realize all steps for customizing and fine-tuning a BCI system: feature extraction & selection, classifier training.HappyFeat also allows to interface with BCI softwares (OpenViBE for the moment!) in order to facilitate the whole BCI workflow, from data acquisition to online classification.The focus is put on ease of use, trial-and-error training of the classifier, and fast and efficient analysis of features of interest from BCI sessions.Key FeaturesEasy to use GUIallowing to extract and visualize classification features, and select the most relevant ones for training a classifier.UseSpectral PowerorCoherence-basedfeatures for classification. HappyFeat allows to extract & visualize both types of features in parallel, andmix them at the training level.Feature selection and classifier training can be done multiple times in a row, until satisfactory results are achieved.Aworspace management systemkeeps tracks of all extraction- and training-related manipulations, and enables a high degree of reproducibility.RequirementsPython 3.9 or more recentPython packages : shutils / PyQt5 / numpy / MNE / matplotlib / scipy / spectrum / statsmodel / pandasOpenViBE Version 3.5.0:http://openvibe.inria.fr/downloads/Installation & Full documentationGo tohttps://happyfeat.readthedocs.io/en/latest/for more details!LicenseThis software is licensed using BSD 3-Clause. Please refer to LICENSE.md for more details.
Package: happyjar
Happy Jar CLIAn easy to use CLI for storing good memories and gratitiude.# basic logging$happylog"Happy text here! :D"# view logs with$happygetall# or,$happygettodayInstallationpipinstallhappyjarBinaries:Download the binary for your platform from theArtifactssection of the latestGitHub Actionsrun.What is it?SourceUsage$happy--help
usage:happy[-h]{log,get}...

Logyourgoodmemoriesandgratitiude.

positionalarguments:{log,get}loglogsanentrygetgetsentries

optionalarguments:-h,--helpshowthishelpmessageandexitexamples:
happylog"i am so happy because you starred this project's repo on github xDD"happygetallExampleInspired bymichelle/happyTodoAdd support for markdown emojis with the:emoji:format. Use Textualize/rich for this.CheckIssuesfor more.ContributorsHitBlastthe MightyDiwash Dahalthe ConquerorFranklin Ikehthe NeatMicah Woodthe Strong🎉 Commit labelsIf you're interested in the commit labels used in this repo, check out mygit commit emojiproject
Package: happyml
HappyML (Machine Learning Python Library)Machine Learning Python library for academic purposes.HappyMLis a
little project supposed to be used by beginners in the Machine Learning
field. It has simple implementations of the more common algorithms.HappyMLonly depends onnumpyandmatplotlib. The high level of
those libraries makes easy to write and read the code.InstallationYou can installhappymleasily usingpip:pip install happymlIf you prefer you can clone the repository and install the library viasetup.py:git clone https://github.com/guiferviz/happyml-py.git happyml
cd happyml
sudo python setup.py installGetting startedCheck your installation with:importhappymlhappyml.greet()If everything is OK you will see the output:Those about to learn we salute you :)DocumentationDev documentation:http://happyml.readthedocs.io/en/dev/ContactMail me (guiferviz) or create an issue.Remember to be HAPPY :smile: :blush: :relaxed: