Saravanan666/pypi-org huggingface dataset:
Package: history-set
# History Set #A Set implementation that tracks added and removed elements.## Usage ##~~~python
>>> from history_set import HistorySet
>>> history_set = HistorySet([1, 2, 3])
>>> history_set.add(4)
>>> history_set                   # Prints: {1, 2, 3, 4}
>>> history_set.added()           # Prints: {4}
>>> history_set.remove(1)
>>> history_set                   # Prints: {2, 3, 4}
>>> history_set.removed()         # Prints: {1}
>>> history_set.reset()
>>> history_set.added()           # Prints: set()
>>> history_set.removed()         # Prints: set()
~~~## Special case ##By default, if an element is added and later removed, it will not be tracked in history~~~python
>>> history_set = HistorySet([1, 2, 3])
>>> history_set.add(4)
>>> history_set.remove(4)
>>> history_set.added()           # Prints: set()
>>> history_set.removed()         # Prints: set()
~~~If you require these elements to be tracked, you can construct the object with theeidetickeyword argument~~~python
>>> history_set = HistorySet([1, 2, 3], eidetic=True)
>>> history_set.add(4)
>>> history_set.remove(4)
>>> history_set.added()           # Prints: {4}
>>> history_set.removed()         # Prints: {4}
~~~By default, thereset()method will clear the entire history~~~python
>>> history_set = HistorySet([1, 2, 3])
>>> history_set.add(4)
>>> history_set.added()           # Prints: {4}
>>> history_set.remove(2)
>>> history_set.removed()         # Prints: {2}
>>> history_set.reset()
>>> history_set.added()           # Prints: set()
>>> history_set.removed()         # Prints: set()
~~~If you require reseting only theadded()orremoved()history, you can call theresetmethod withaddedorremovedbooleans values to specify which history you with to reset~~~python
>>> history_set = HistorySet([1, 2, 3])
>>> history_set.add(4)
>>> history_set.added()           # Prints: {4}
>>> history_set.remove(2)
>>> history_set.removed()         # Prints: {2}
>>> history_set.reset(added=True)
>>> history_set.added()           # Prints: set()
>>> history_set.removed()         # Prints: {2}
~~~## Test ##You can run the tests using [tox](https://tox.readthedocs.io/en/latest/)~~~shell
tox
~~~## Publish ##To publish a new version of this package your Pypi user needt to be added to the project. (Ask Tjaart to give you access)~~~shell
# Update version number in setup.pypython setup.py sdist
twine upload dist/*
~~~
Package: history-view
history-viewA little tool to visually browse your console history.What it looks like to scan through your history now:ArgumentsArgumentDescription-s, --searchFilter history by regex.--cDon't invoke selected command, instead copy to clipboard.Known IssuesStill usessubprocessto invoke. It should bemostlythe same given that environment variables are passed in, but a straightforward return of the command is something that would be better.Only supports Windows and Powershell.Only adds to the long-term history. Not the history of the current shell (available via up/down)AddendumYes, I am entirely aware that I could get the same affect in powershell withGet-History. Not the point!
Package: hist-plot
Decision Score HistogramA new histogram-based approach for visualizing anomaly detection algorithm performance and prediction confidence.BackgroundPerformance visualization of anomaly detection algorithms is an
essential aspect of anomaly and intrusion detection systems.
It allows analysts to highlight trends and outliers in anomaly
detection models results to gain intuitive understanding of detection
models. This work presents a new way of visualizing anomaly
detection algorithm results using a histogram.Importance of the Visualization Approachprovides a better understanding
of detection algorithms performance by revealing the exact
proportions of true positives, true negatives, false positives,
and false negatives of detection algorithms.provides insights into the strengths and weaknesses of detection
algorithms performance on different aspects of a datasets unlike
previous approaches that rely on only positive and negative
decision scores.can be applied to performance visualization and analysis of
supervised machine learning techniques involving
binary classification of imbalanced datasets.UsageBelow is an example of how to use this histogram.Input:decision_scores: Decision/Anomaly scores of detection or binaryclassification algorithm  --> input to class objectground_truth: binary class labels of normal (+1) and anomalous (-1)
data instances  -->  input to class objectfig_name (Optional: string): name for saving output plot; default is 'hist_plot'  --> input to hist_plot methodInput data type:list, numpy array, pandas DataFrame, pandas SeriesOutput:Histogram visualization of true positives, true negatives, false
positives and false negatives with their prediction confidences.General use caseimporthist_plotfig=hist_plot.AnomalyScoreHist(decision_scores,ground_truth)fig.plot_hist(fig_name)Note: The data class convention used in this work is:1: represents normal class-1: represents the anomalous classThe code can also handle supervised binary predictions whereby 1: class A and -1: class B.Exampleimporthist_plotfig=hist_plot.AnomalyScoreHist(test_dec,test['class'])fig.plot_hist('IF_histogram')wheretest_decis the decision score output of isolation forest
detection algorithm on test set 2 ofTLIGHT datasetandtest['class']is the class label (1, -1).ReferencesUsers can refer to our paper below for further insight and
examples:Aboah Boateng E, Bruce JW. Unsupervised Machine Learning
Techniques for Detecting PLC Process Control Anomalies. Journal of Cybersecurity and Privacy.
2022; 2(2):220-244.https://doi.org/10.3390/jcp2020012
Package: histpy
The histpy library provides a Histogram class which is, in essence, an array with axes attached defining the value of bin boundaries. It can handle an arbitrary number of dimensions, be accessed in a similar way as a numpy array, be projected, sliced, multiplied, fitted, plotted, etc. The histograms can be weighted and they will propagate errors during all operations. The under and overflow contents are tracked. Sparse histograms are also supported. The histpy's Histogram class is loosely based on a ROOT histogram but using a more pythonic interface.Full documentation:https://histpy.readthedocs.io
Package: histr
histrI am only getting started, this package intends to be one stop solution for any kind of manipulation on Devanagari string, at the outset I have the following goals:Tokenize the Devanagari string at phoneme level, i.e. break down "अंकित" to ["अं", "कि", "त"]Identify and autocorrect (optionally) the text like अंंिकत to अंकितI will keep adding to the list as came across more usecases or feature requests from downstream usersIf you have any ideas on how to do this or you want to improve upon my work, PR(s) are always welcome.
Package: histutils
HiST UtilsHiST project raw video data reading utilities.Installpython -m pip install -e .User Programs/ScriptsThese functions are primarily made to be used from the Terminal by a
human, they implement a complete program using the module functions.RunSimulPlaySimultaneous video playback of two or more cameras.-i input file list (.h5)-t Time range start/stop-o Output directory for plots (optional, slow)Example$pythonRunSimulFrame.py-i~/data/cmos2013-01-14T1-15.h5~/data/ccd2013-01-14T1-15.h5using thedata from January 13, 2013
experimentduring
active plasma time.ConvertDMC2h5.pyTypically used by our staff internally to convert our binary .DMCdata
files to human- and fast processing- friendly HDF5 files.Examplepython ConvertDMC2h5.py -p 512 512 -b 1 1 -k 0.0188679245283019 -o testframes_cam0.h5 ~/data/2013-04-14T07-00-CamSer7196_frames_363000-1-369200.DMCdata -s 2013-04-14T06:59:55Z -t 2013-04-14T08:54:10Z 2013-04-14T08:54:10.05Z

python ConvertDMC2h5.py -p 512 512 -b 1 1 -k 0.0333333333333333 -o testframes_cam1.h5 ~/data/2013-04-14T07-00-CamSer1387_frames_205111-1-208621.DMCdata -s 2013-04-14T07:00:07Z -t 2013-04-14T08:54:10Z 2013-04-14T08:54:10.05ZWhenEnd.pyJust predicts the end of a .DMCdata file "does this file cover the
auroral event time?"Module FunctionsThese functions are typically targeted for calling from other programs,
however, many of these can also be used from the Terminal directly.ExamplesMany more possibilities exist, the-hoption on most functions will
give some hints as to what the program can do.Reference ExamplesThese examples are old, now we use HDF5 files. Kept for reference only.Read .DMCdata file from within a Python scriptfrom histutils import rawDMCreader
data = rawDMCreader.goRead('myfile.DMCdata')[0]Using rawDMCreader.py from Terminalcd histutils/histutils
python3 rawDMCreader.py ~/data/
Package: histy
HistyHisty is a command line tool for generating histogram plots from timestamped logs.
Timestamps must be in ISO format.
Histy is useful for quick visual analysis of log frequencies from the command lineInstallation (Requires Python 3.6+ and pip)pip install histyParameters:--bucket_time_sor-b: the duration of each histogram bucket in secondsSample usage:catserver.log|histy-b60dockerlogsmy-app--since"2020-01-06 12:37:30"--until"2020-01-06 12:38:30"|histy-b10Output:Histogram:
2020-01-15T03:13:01  :  ######### 63
2020-01-15T03:13:11  :  ###### 41
2020-01-15T03:13:21  :  #### 28
2020-01-15T03:13:31  :  ##### 34
2020-01-15T03:13:41  :  ############# 88
2020-01-15T03:13:51  :  ######### 61
2020-01-15T03:14:01  :  ########################## 181
2020-01-15T03:14:11  :  ###################################################################### 470
2020-01-15T03:14:21  :  #### 31
2020-01-15T03:14:31  :  ######## 54
2020-01-15T03:14:41  :  ####### 48
2020-01-15T03:14:51  :   5
Package: hitbtc-api-brunohenz
HitBTC Client APIThis is a simple client to connect in the HitBTC Exchange API.The main objective is provide a simple interface to consume the methods to consulting, create orders, sell and buy cryptos in HitBTC.Installationpip install hitbtc-api-brunohenzPré-ReqTo use de client and connect to HitBTC API, is necessary create a account in the exchange and generate a API KEY in pathhttps://hitbtc.com/settings/api-keysUsagefromhitbtcapi.hitbtcimportHitBtcAPIKey='API-KEY'SecretKey='SECRET-KEY'client=HitBtc(APIKey,SecretKey)# Get OrderBooks by Symbolorderbooks=client.get_orderbook('smartbtc')print(orderbooks)# Create a orderorder=client.create_order({'symbol':'smartbtc','side':'buy','quantity':1,'price':'0.000148'})print(order)Avaliable MethodsCurrenciesclient.get_currencies()Order Booksclient.get_orderbook('smartbtc')Ordersget_orders()create_order({'symbol': 'smartbtc', 'side': 'buy', 'quantity': 1, 'price': '0.000148'})Tradesget_trades_history('smartbtc')
Package: hitbtc-wss
hitbtc_wssHitBTC Websocket API 2.0 Client written in Python 3.Forked fromCrypto-toolbox/hitbtc_wss.  At the time of this writing,
Crypto-toolbox had not accepted a pull request into his repo in 7 months.  Seems like they might have
moved on to do other things.  I figured I'd pick the ball up and run with it.Release HistoryDateDescription09/02/2018Published bug fix to PyPi so theloginmethod works with HitBTC v2 login method.The client supplies data both visually via console, as well as python objects via itsHitBTC.recv().
It's important to note that this does not receive data from the API directly -
instead, the data is pulled from aqueue.Queueobject, which defaults to a length of
100 items. So only the last 100 messages will be cached - either make sure you process the messages
fast enough, or increase the length of the queue (can be done by passing theq_maxsizekwarg on
instantiation).By default, data is unpacked - that means you will never see the rawJSONRPCmessage
(this, too, can be turned off by passingraw=Trueupon initialization). This will, however, also
turn off all handling of error messages etc.For an in-depth description of the client and its methods, please see the documenation atreadthedocs.orgInstallationStable:pip install hitbtc_wssRelease Candidate:pip install --pre hitbtc_wssExample Usageimporttimeimportqueuefromhitbtc_wssimportHitBTCc=HitBTC()c.start()# start the websocket connectiontime.sleep(2)# Give the socket some time to connectc.subscribe_ticker(symbol='ETHBTC')# Subscribe to ticker data for the pair ETHBTCwhileTrue:try:data=c.recv()exceptqueue.Empty:continue# process data from websocket...c.stop()
Package: hitch
Hitch is a UNIX-based testing framework for writing integration tests with an emphasis on:Minimizing and eliminatingbrittle testsTest readabilityLoose couplingTest realismTests thatfail fastandfail clearlyAvailable pluginsHitch comes with a variety of plugins to aid you to realistically testing various
kinds of software, components and scenarios, including:Python(includes Django and Celery service definitions)PostgresqlRedisWeb apps (using selenium)Command line apps (using pexpect)CronMySQLRabbitMQElastic SearchPlugin documentationGetting startedSee thequickstart tutorialon how to
get started testing an existing project.Also check outcookiecutter-djangoif you want to start a new Django project with tests.StatusHitch is currently in beta.It is regression tested on:Operating Systems : Mac OS X Yosemite, Ubuntu, Debian, Fedora and Arch Linux.Python versions : 3.5.0, 3.4.3, 3.4.0 and 3.3.0(what about python 2?)It does not currently work on Windows.Seetested onfor more details on
how the framework is tested (with itself, naturally).Contents of this projectThis project contains:The code for the bootstrapper scriptDocumentation for the whole project (hosted at readthedocs)Code for other components is at:https://github.com/hitchtest/
Package: hitchbuildpg
HitchBuildPgA small, self contained python library for building postgres database locally that, on first run will:Downloads and compiles a specified version of postgres.Builds a database from a series of SQL commands and by restoring a database dump file.Takes a snapshot of the newly built database files by taking a copy of the folder.On subsequent builds, it will skip the long, expensive steps of downloading, compiling postgres
and restoring a database from a .sql file and just overwrite the data files.importhitchbuildpgpostgres_version="10.10"pgapp_dir="{}/postgres-{}".format(share,postgres_version)pgapp=hitchbuildpg.PostgresApp(pgapp_dir,postgres_version)classDataBuild(hitchbuildpg.DataBuild):defrun(self):self.run_sql_as_root("create user myuser with password 'mypassword';")self.run_sql_as_root("create database mydb with owner myuser;")self.load_database_dump(database="mydb",username="myuser",password="mypassword",filename="dump.sql")pgdata=hitchbuildpg.PostgresDatafiles("./myappdata",pgapp,DataBuild(),)pgdata.ensure_built()db_service=pgdata.server()db_service.start()psql=db_service.psql("-U","myuser","-p","15432","-d","mydb",).with_env(PG_PASSWORD="mypassword")psql("-c","select name from cities where location = 'GB';").run()# Prints output of SQL statementpsql("-c","delete from cities where location = 'GB';").run()db_service.stop()
Package: hitchcelery
HitchCeleryHitchCelery is a plugin for the Hitch test framework that lets you run and
interact with Celery as part of a test.Use with HitchInstall like so:$ hitch install hitchcelery# Service definition in engine's setUp:self.services['Celery']=hitchcelery.CeleryService(version="3.1.17",# Mandatorypython="{}/venv/bin/python".format(PROJECT_DIRECTORY),# Mandatoryapp="remindme",# Mandatorybeat=False,# Optional (default: False)concurrency=2,# Optional (default: 2)loglevel="INFO",# Optional (default: INFO)broker=None,# Optional (default: None)needs=[self.services['Redis'],]# Optional (default: no prerequisites))# Interact during the test:self.services['Celery'].help().run()[Printsoutput]self.services['Celery'].status().run()[Printsstatusoutput]self.services['Celery'].control(*args).run()[Printsoutput]self.services['Celery'].inspect(*args).run()[Printsoutput]See this service in action at theDjangoRemindMeproject.
Package: hitchcli
HitchCLIHitchCLI is a plugin for the Hitch test framework that lets you test
command line applications. It includes a wrapper around pexpect to
let you write steps to interact with interactive command line
applications.WARNING : The API for HitchCLI is currently very unstable. It will
change frequently and without warning. It is recommended that you
wait a few weeks before using it.DocumentationSee:https://hitchtest.readthedocs.org/en/latest/services/cli.html
Package: hitchcron
HitchCronHitchCron is a plugin for the Hitch test framework that lets you mimic
the effect of having a cron run during your tests by running a command
repeatedly.Use with HitchInstall like so:$ hitch install hitchcron# Service definition in engine's setUp:self.services['Cron']=hitchcron.CronService(run=self.services['Django'].manage("trigger").command,# Python list containing command + argsevery=1,# Run every 1 seconds)See this service in action at theDjangoRemindMeproject.
Package: hitchdjango
HitchDjangoHitchDjango is a plugin for the Hitch test framework that lets you run and
interact with Django as part of a test.When the plugin starts Django,beforerunning runserver, it will:Check the version and fail if it is different to what is specified.Run migrations (using manage.py migrate).Get the URL using localhost + the specified port and put it in sites.site.Install all specified Django fixtures.Currently HitchDjango runs only on Django 1.8 and above. Please raise a ticket
if you need an earlier version.Use with HitchInstall like so:$ hitch install hitchdjango# Service definition in engine's setUp:self.services['Django']=hitchdjango.DjangoService(version="1.8",# Mandatorypython="{}/venv/bin/python".format(PROJECT_DIRECTORY),# Mandatorymanagepy=None,# Optional full path to manage.py (default: None, assumes in project directory)django_fixtures=['fixture1.json',],# Optional (default: None)port=18080,# Optional (default: 18080)settings="remindme.settings",# Optional (default: settings)needs=[self.services['Postgres'],]# Optional (default: no prerequisites))# Interact during the test:>>>self.services['Django'].manage("help").run()[Printshelp]>>>self.services['Django'].url()http://127.0.0.1:18080/>>>self.services['Django'].savefixture("fixtures/database_current_state.json").run()[Savesfixture]See this service in action at theDjangoRemindMeproject.
Package: hitchenvironment
HitchEnvironment================HitchEnvironment is a plugin for the Hitch testing framework that lets youdescribe your environment and verify that it correct.It is supposed to provide some measure of safety for tests that might pass on,for example, a 64 bit machine but fail on a 32 bit machine, by makingthe environment a test runs on declared explicitly.It is required by HitchServe_ to run, requiring you to specify yourenvironment.Currently, it lets you describe the following:* Platform (linux2, win32, cygwin, darwin, os2, os2emx, riscos, atheos)* System bits (32 or 64)* Access to internet (True or False)Use with Hitch==============Install like so::$ hitch install hitchenvironment.. code-block:: python>>> import hitchenvironment>>> hitchenvironment.class_definition()hitchenvironment.Environment(platform="linux2", systembits=64, requires_internet_access=True)>>> hitchenvironment.Environment(platform="linux2", systembits=64, requires_internet_access=True).match()See this plugin in action at the DjangoRemindMe_ project... _HitchServe: https://github.com/hitchtest/hitchserve.. _DjangoRemindmMe: https://github.com/hitchtest/django-remindme
Package: hitchexamplefiles
HitchExampleFilesA group of example files which can be used for testing - a big jpeg, small jpeg, pdf and png.Usespath.py,
so you can use path.py API to do anything with the files.E.g... code:: pythonimport hitchexamplefiles
from path import Pathhitchexamplefiles.jpeg_large.copy(Path("/path/to/your/jpegname.jpeg"))
hitchexamplefiles.jpeg_small.copy(Path("/path/to/your/jpegname.jpeg"))
hitchexamplefiles.pdf_one_page.copy(Path("/path/to/your/pdf_one_page.pdf"))
hitchexamplefiles.png_large.copy(Path("/path/to/your/png_large.png"))hitchexamplefiles.asset_directory.joinpath("jpeg_large.jpg")
hitchexamplefiles.asset_directory.joinpath("jpeg_small.jpg")
hitchexamplefiles.asset_directory.joinpath("pdf_one_page.pdf")
hitchexamplefiles.asset_directory.joinpath("png_large.png")
Package: hitchhiker
This is the description file for the project.The file should use UTF-8 encoding and be written using ReStructured Text. It
will be used to generate the project webpage on PyPI, and should be written for
that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not
a good idea, although a simple “What’s New” section for the most recent version
may be appropriate.
Package: hitch-pip-tools
pip-tools keeps your pinned dependencies fresh.Home-page:https://github.com/nvie/pip-tools/Author: Vincent Driessen
Author-email:me@nvie.comLicense: BSD
Description: UNKNOWN
Platform: any
Classifier: Development Status :: 5 - Production/Stable
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: System Administrators
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Topic :: System :: Systems Administration
Package: hitchpostgres
HitchPostgresHitchPostgres is a plugin for the Hitch test framework that lets you run and
interact with Postgres in an isolated way as part of a test.Before starting the service, it runs the initdb command to create all required
data files for a postgresql database in the .hitch directory. This means that
whatever you do, you will not interfere with the system postgres files. The
system postgres does not even have to be running.After starting the service, it creates any users and databases specified that
may be required for your app to start.During the test it provides convenience functions psql, pg_dump and pg_restore
so that you can interact with the database using IPython or in your test.UseSee:https://hitchtest.readthedocs.org/en/latest/api/postgres.htmlFeaturesCreates data files from scratch using initdb in the .hitch directory. Complete isolation of data from system postgres.Starts up on a separate thread in parallel with other services when running withHitchServe, so that your integration tests run faster.Run the server on whatever port you like.Version set explicitly to prevent “works on my machine” screw ups caused by running different versions of Postgres.
Package: hitchpython
HitchPython===========HitchPython is a plugin for the Hitch test framework that lets you testpython programs. Specifically, it includes code to:* Download, build and create a virtualenv from all versions of python.* Run a Django runserver service using hitchserve_.* Run a Celery service using hitchserve_.The Django runserver service will:* Optionally, run migrations and insert a site into django_sites table, prior to starting the service.* Install fixtures.* Run on a specific port.* Get the URL.* Generate a runnable manage subcommand.Documentation=============See:* https://hitchtest.readthedocs.org/en/latest/services/django.html* https://hitchtest.readthedocs.org/en/latest/services/celery.html* https://hitchtest.readthedocs.org/en/latest/api/package_api.html
Package: hitchquickstart
HitchQuickstart is a hitch plugin that generates a base hitch project from scratch,
including an engine.py, hitchreqs.txt, settings files, system.packages and a stub
test.Install and RunIf you want to run hitch quickstart from scratch, simply copy and paste the following 3 command:~/yourproject$ mkdir tests

~/yourproject/tests$ cd tests

~/yourproject/tests$ curl -sSL https://hitchtest.com/init.sh > init.sh ; chmod +x init.sh ; ./init.shNote that the exact name of the tests directory is not important.If you have an existing hitch environment:$ hitch install hitchquickstart

$ hitch quickstart