Saravanan666/pypi-org huggingface dataset:
Package: head-controller
RequirementsAnaconda Python >= 3.7QuickstartQuickly train 4 gestures for the model to learn. Press the UP, DOWN, RIGHT, and LEFT arrows on your keyboard to 'label' each gesture in realtime. After 30 seconds you'll be prompted to save (append) the new training data. It will immediately show you a cross-validation score of the fitted data.
Initialize, Train, and Predict in less than 60 seconds (using your webcam).import head_controller.db as db
import head_controller.Camera as Camera

# Initialize gesture training data
db.setup_db()

# Capture webcam gestures with live arrow-key labelling
Camera.capture_review_submit_labels()

# Realtime predict webcam gestures
Camera.check_video_frame_data_predict()
Package: headctools
This tool includes a bunch of algorithms for preprocessing CT images &
PyTorch based models for performing brain segmentation or skull
reconstruction on craniectomy images.The implemented convolutional neural networks are based on theU-Netmodel,
which was adapted to these particular problems.RequirementsYou should have Python 3.7+ installed in your system. If you are using the
registrarion commands, you should manually installFSLPackage installFor installing the package using pip, run the following command:pipinstallheadctoolsYou can check some usage examples in thecolab notebookand thereadthedocs page.Citing our workIf you have found this repo useful, please consider citing our work@incollection{Matzkin2020,
  doi = {10.1007/978-3-030-59713-9_38},
  url = {https://doi.org/10.1007/978-3-030-59713-9_38},
  year = {2020},
  publisher = {Springer International Publishing},
  pages = {390--399},
  author = {Franco Matzkin and Virginia Newcombe and Susan Stevenson and Aneesh Khetani and Tom Newman and Richard Digby and Andrew Stevens and Ben Glocker and Enzo Ferrante},
  title = {Self-supervised Skull Reconstruction in Brain {CT} Images with Decompressive Craniectomy},
  booktitle = {Medical Image Computing and Computer Assisted Intervention {\textendash} {MICCAI} 2020}
}Project logo icons made by Pixel perfect fromwww.flaticon.com
Package: header2whatever
header2whatever (h2w)Generate arbitrary files from C/C++ header files using CppHeaderParser to read
the input files and Jinja2 templates to generate the outputs.This grew out of a desire to generate pybind11 wrapping code from C++ header
files. pybind11gen was created, but then I wanted to generate more things…There are still rough edges, and the documentation is mostly nonexistent, but
pull requests with fixes/improvements are very welcome!As of 0.3.0, h2w requires Python 3.3+Installpip install header2whateverUsageFirst, you need to create a jinja2 template that represents whatever you want
to generate from the header file. For example, maybe you want to describe the
functions in yaml:---
{% for header in headers %}
{% for fn in header.functions %}
{{ fn.name }}:
  returns: {{ fn.returns }}
  params:
  {% for param in fn.parameters %}
  - { name: {{ param.name }}, type: "{{ param.type }}" }
  {% endfor %}

{% endfor %}
{% endfor %}And let’s say you have the following header filefoo.h:void some_fn(int i);
int returns_int(int p1, char* p2);You can execute the following:h2w foo.h -o foo.ymlAnd you’ll get the following output:---
returns_int:
  returns: int
  params:
  - { name: p1, type: "int" }
  - { name: p2, type: "char *" }

some_fn:
  returns: void
  params:
  - { name: i, type: "int" }As you can see, while this is a silly example, this approach is very flexible
and fairly powerful.Currently, the data structure passed to the template isn’t documented – but
it’s a filtered version of whatever CppHeaderParser outputs when it parses a
header.See the examples folder for more examples.Batch modeIf you need to process multiple files, or just want to record the parameters for
autogenerating a file without writing a shell script, batch mode is useful. You
pass two parameters: a yaml file with the configuration, and an output directory
to write the files to.Using data from external sourcesSometimes you want to mix in data that CppHeaderParser can’t give you. If you
pass the--yamloption, it will load the yaml into a dictionary and make it
available to the template as the ‘data’ variable.You can also pass key=value parameters via the--paramoption, and
the specified keys will be available to the template.Custom processingWhen you need to do more complex logic that a jinja2 template just isn’t
appropriate for, you can specify a python file to load custom hooks from.See [the default hooks](header2whatever/default_hooks.py) for documentation.LicenseApache 2AuthorDustin Spicuzza (dustin@virtualroadside.com)
Package: headercop
headercopEnforce license headers in files.FeaturesCheck to see if file headers are present in files. Useful for CI
pipelines.Inject file headers if missing to filesBuilt in support for Python and Terraform files, easy to add support
for others.TODOProper documentation…Remove headers (in prepareation to change headers, e.g. copyright
year)CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2017-04-22)First release.0.1.1 (2017-05-16)Include licenses in package (bsd3 for now)
Package: headerindexer
HeaderIndexerA system to bind aliases to indexes of headers in a matrix.Given a dict of header aliases paired to the actual header value (or an iterable of possible values)
creates a dict with entries {'alias': column_index}Includes interactive prompts to manually select headers when unable to find, and optional duplicate
checks for aliases sharing indexesInstallationpip install headerindexerUsing HeaderIndexerfromheaderindexerimportHIindexer=HI()headers=["Date","OS","TrackingID","DNSHostname",b"DNSHostname",77]aliases={b'hostname':["DNSHostname",b'DNSHostname'],"track":("1TrackingID1",'TrackingID'),"OS":"OperatingSystem",7:77}aliases_to_indexes=indexer.run(headers,aliases)Assume we've extracted a row of headers from a spreadsheet. Create a dictionary like aliases, and
pass them both to indexer (HI.run())# aliases_to_indexes, generated above{b'hostname':3,'track':2,'OS':1,7:5}The returned dictionary can be used to reliably call on the appropriate column by given aliasesHeaders not found/Duplicates headersBy default, when an alias' header cannot be located headerindexer will prompt the user to manually
select from a list of all headers, one by oneAdditionally HI.allow_duplicates can be set to False in or after init, enabling a similar mode of
prompting whenever two or more aliases share the same index value
Package: header-printer
header-printerPython package for printing a nicely formatted header.InstallationRun the following command to install:pipinstallheader-printerUsageIn you script import and use functionprint_header.fromheader_printerimportprint_headerprint_header('Some text')Header will be stretched to the full length of the terminal.
The provided text will be centered.********************************************Sometext********************************************DevelopmentTo install all dependencies required for local development, run:makeinstall-dev
Package: header-propagation
Header Propagation MiddlewareMiddleware for propagating headers from incoming requests to outgoing requests for FastAPI.Installationpipinstallheader-propagation-middlewareSetupTo setup the middleware, you need to add it to your FastAPI app.Adding Middlewarefromheader_propagation_middlewareimportHeaderPropagationMiddlewareapp=FastAPI()app.add_middleware(HeaderPropagationMiddleware,header_names=["header1","header2"])Configurable middleware argumentheader_namesType:List[str]Default:[]Description: The list of headers to propagate.Accessing propagated headersYou can access the propagated headers using thepropagated_headersobject.fromheader_propagation_middlewareimportpropagated_headerspropagated_headers.get()propagated_headersType:dictDefault:{}Description: The dictionary of propagated headers.TestsRunning testpython-mpytestRunning test with coverage reportpython-mpytest--cov--cov-report=html:reports/html_dir
Package: headfake
HeadfakeWhat is Headfake?Healthdatafaker is a Python-based package which allows the user to use a declarative approach to create fake or test data sets.
using either Python code, or a YAML or JSON-based template file.The package can be embedded directly into Python scripts, or it can be used through a command-line script.It takes ideas from other declarative packages (e.g. pydbgen), but also adds support for a number of additional features
including statistically distributed random values; dependent fields and custom fields as well as approaches for
transforming generated fields before/after the generation process.How do I install and use Headfake?To get started quickly, you can use pip to install it:pipinstallheadfakeThen test it out using one of the example YAML templates:headfakeexamples/patients.yaml--no-rows=100You should get 100 rows of generated data.For further information on using Headfake head over toTutorialsor theUsagepage.Why would I use Headfake?Headfake makes it simple and straightforward to generate fake or test data. It has a number of features which make this easier:Support for shareable template-based config or direct Python implementation to setup and perform the data generation.Embeddable data generation into projects (either using a YAML or JSON config or using Python data structures/classes).Generation of names and contact details through use of the Python package Faker.Randomised names can be output based on a gender field.More realistic simulated data uses statistical distributions to create date of birth and also probability-based option values. Other approaches to simulate real data are also being investigated.Clinical data supported includes random NHS numbers and deceased flags/date of death based on age-based odds of death.Dependent fields (e.g. one field's values are dependent on the values from one or more)Operation fields (e.g. combine generated values using specific operations such as add or subtract)Field data can be looked up from another file using a key field, allowing re-use of patient details in a different field set.A selection of fields to handle generation of different types of data.Ability to create and use custom fields to generate your own data types and valuesSupport for transformers which pre or post-process data once it's been generatedIs Headfake being actively maintained?Yes, we are using Headfake is our own projects and as result are keep it maintained and adding new features when we need them.Is Headfake suitable for my project?The library has been released under an MIT license so can be embedded into your own tools with minimal restrictions on use.If I use Headfake to generate data in my research project which source should I cite?We are working on a journal paper, for now please cite the project URL (https://rcfgroup.github.io/headfake).
Package: headfuck
HeadfuckA Brainfuck-like esoteric programming language based on matrices.
This language has all of the usual Brainfuck commands, as well as a few more, bolded below:> moves forward in an array< moves backward in an array+ adds one to the value of the current cell in the array- removes one from the value of the current cell in the array. displays the value of the current cell to the user, requests user input to modify the value of the current cell[ starts a loop] closes a loop^ moves up in a matrixv mves down in a matrix# displays the first ten rows of the matrix! reads and interpret the contents of a file& dumps the outputs of the code to a file* multiplies the value of the current cell by two/ sets the value of the current cell to zero? sets the value of the current cell to a random ASCII-compatible number= sets a variable with the name of the letter after it (e.g. =a creates a variable called a)@ sets the value of the current cell to the variable with the name of the letter after it (e.g. @a sets the current cell to a)Headfuck adds I/O and 2-D arrays on top of the functionalities of basic Brainfuck.Installing this package viapip3 install headfuckwill grant you access to theheadfuckandhffcommands.headfuckis a live interpreter where you simply type that command and then type your code as input.hffinterprets a file that is passed as an argument, e.g.hff file.bf.
Package: headjack
HeadjackHeadjack is a chat-based semantic layer for metrics platforms.Docker ComposeThe included docker compose setup launches a headjack,chroma, and jupyter lab container.Pull down the chroma repo which is contained in this repo as a submodule.gitsubmoduleinit
gitsubmoduleupdateStart the docker compose environment.dockercomposeupHeadjack:http://localhost:16400/docsJuptyer Lab:http://localhost:16401ChromaDB:http://localhost:16402/docsLint, Test, and Check CoverageThis project includes a Makefile for use withGNU Make.Run linters.make lintRun tests.make testRun tests with coverage.make coverage
Package: headjackai-sdk
# Headjack AI SDK![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)Headjack AI is a advanced machine learning tool for the modularity of features engineering, which provides an effective and flexible knowledge transfer framework that sublimates source data sets to pretrained feature engineering function for any predictive machine learning task.With Headjack-AI SDK, you can easily implement Headjack-AI server into your application with Python. This SDK library contains knowledge fit, transform, and running your custom inference models and custom tasks with Headjack-AI.To know more about Headjack AI, please contact us to try it out!(jim_liu@symphox.net)## System Requirement
* python3.7## Install
Install and update using pip:`bash pip installheadjackai-sdk`## Links
For more details on design, guidance on setting up a development environment, and SDK usage.Headjack AI Platform: <http://www.headjackai.com/>Headjack AI SDK Code: <https://github.com/jimliu741523/headjackai-sdk>## History0.2.12 fix check status from AutoKnow0.2.11 fix example0.2.10 refactor AutoKnow
Package: headless-ida
Headless IDAInstallpipinstallheadless-idaUsageUse it as a normal Python module.# Initialize HeadlessIdafromheadless_idaimportHeadlessIdaheadlessida=HeadlessIda("/path/to/idat64","/path/to/binary")# Import IDA Modules (make sure you have initialized HeadlessIda first)importidautilsimportida_name# Or Import All IDA Modules at Once (idaapi is not imported by default)# from headless_ida.ida_headers import *# Have Funforfuncinidautils.Functions():print(f"{hex(func)}{ida_name.get_ea_name(func)}")Use it as a command line tool.# Interactive Console$headless-ida/path/to/idat64/path/to/binary
Python3.8.10(default,Nov142022,12:59:47)[GCC9.4.0]onlinux
Type"help","copyright","credits"or"license"formoreinformation.(InteractiveConsole)>>>importidautils
>>>list(idautils.Functions())[0:10][16384,16416,16432,16448,16464,16480,16496,16512,16528,16544]>>># Run IDAPython Script$headless-ida/path/to/idat64/path/to/binaryidascript.py# One-liner$headless-ida/path/to/idat64/path/to/binary-c"import idautils; print(list(idautils.Functions())[0:10])"# In case you like IPython$headless-ida/path/to/idat64/path/to/binary-c"import IPython; IPython.embed();"Advanced UsageRemote ServerStart a Headless IDA server$headless-ida-server/path/to/idat64localhost1337&Connect to the server in Python script# Initialize HeadlessIdafromheadless_idaimportHeadlessIdaRemoteheadlessida=HeadlessIdaRemote("localhost",1337,"/path/to/local/binary")# Import IDA Modules (make sure you have initialized HeadlessIda first)importidautilsimportida_name# Have Funforfuncinidautils.Functions():print(f"{hex(func)}{ida_name.get_ea_name(func)}")Connect to the server in command line# Interactive Console$headless-idalocalhost:1337/path/to/local/binary# Run IDAPython Script$headless-idalocalhost:1337/path/to/local/binaryidascript.py# One-liner$headless-idalocalhost:1337/path/to/local/binary-c"import idautils; print(list(idautils.Functions())[0:10])"ResourcesHeadless IDA ExamplesIDAPython Official DocumentationIDAPython Official ExamplesKnown Issuesfrom XXX import *Usingfrom XXX import *syntax with certain ida modules (like idaapi, ida_ua, etc.) is currently unsupported due to SWIG and RPyC compatibility issues. We recommend importing specific items withfrom XXX import YYY, ZZZ, or importing the entire module usingimport XXX.The issue arises because SWIG, employed for creating Python bindings for C/C++ code, generates intermediary objects (SwigVarlink) that RPyC, our remote procedure call mechanism, cannot serialize or transmit correctly.
Package: headless-pdfkit
The PDFKit package makes use ofwkhtmltopdf, which in turn needs an X Server
to run. In Debian land, this generally requiresxvfb-runwrapper.Theheadless_pdfkitpackage tries to make thehotfixproposed byjakewinsa bit easier to work with.InstallationYou can installheadless_pdfkitby running:pip install headless-pdfkitExamplesSave a simple PDF from string.:from headless_pdfkit import generate_pdf

ret = generate_pdf('<html></html>')
with open('output.pdf', 'wb') as w:
    w.write(ret)Save a simple PDF from string while passing the–auto-servernumparameter toxvfb-run.:options = {
    'auto_servernum': ''
}

ret = generate_pdf('<html></html>', options=options)
with open('output.pdf', 'wb') as w:
    w.write(ret)
Package: headlessvim
Introductionheadlessvimmakes Vim programmable to support developping Vim plugins.The most distinctive characteristic is,headlessvimNEVER needs+clientserverfeature.InstallUsingpip(recommended)pipinstallheadlessvimThe good oldsetup.pypythonsetup.pyinstallUsageA simple example is here:>>>importheadlessvim>>>withheadlessvim.open()asvim:...vim.echo('"spam"')# make sure to quote bare words...'spam'>>>importos>>>env=dict(os.environ,LANG='C')>>>withheadlessvim.open(executable='/usr/bin/vim',args='-N -u /etc/vim/vimrc',env=env):...vim.send_keys('iham\033')...vim.display_lines()[0].strip()...'ham'Integrating tounittest:importunittestimportheadlessvimclassTestVimPlugin(unittest.TestCase):defsetUp(self):self.vim=headlessvim.open()deftearDown(self):self.vim.close()deftestSomeFeature(self):res=self.vim.echo('"ham egg"')self.assertEqual(res,'ham egg')DocumentationSeethe online documentfor more information.TestingExecute:pythonsetup.pytestLicenseThe MIT License.SeeLICENSE.txtfor more information.
Package: headlight
headlightA database migration toolkit.InstallationInstallheadlightusing PIP or poetry:pipinstallheadlight# orpoetryaddheadlightFeaturesTODOUsageCreate migration file# create migration withheadlightnew--nameinitialIt will create a new python file inmigrationsdirectoryDefine schema# migrations/0000_initial.pyfromheadlightimportBlueprint,typesdate="2022-08-21T16:19:13.465195"author="alex"transactional=Truedefmigrate(schema:Blueprint)->None:withschema.create_table('users')astable:table.autoincrements()table.add_column('first_name',types.VarCharType(256))table.add_column('last_name',types.VarCharType(256))table.add_column('email',types.VarCharType(256))table.add_column('password',types.VarCharType(512))table.add_column('active',types.BooleanType(),default='1')table.add_column('photo',types.VarCharType(512),null=True)table.add_column('deleted_at',types.DateTimeType(True),null=True)table.add_created_timestamp('joined_at')table.add_index(['(lower(email))'],unique=True)Execute migrationheadlightupgradeAll migrations will be applied to the databaseRollback migrationheadlightdowngradeThe last migration will be rolled back,
Package: headline-detector
headline_detectorIndonesian Headline Detection Python APIThis is a Python library that provides APIs for detecting headlines in textual data, especially on social media platforms such as Twitter. The library utilizes a model that has been developed and trained on a dataset of Twitter posts containing both headline and non-headline texts, with the assistance of journalism professionals to ensure the data quality.$pipinstallheadline-detectorAvailable scenario and the performanceModelScenario 1Scenario 2Scenario 3Scenario 4Scenario 5Scenario 6Fasttext0.87660.87140.87930.87140.87140.8661CNN0.90810.90810.89500.88980.89500.8898IndoBERTweet0.98950.99210.97380.95800.98430.9685All meassured in accuracyModel ThroughputModelThroughput (Â± Text/seconds)IndoBERTweetÂ±1.3CNNÂ±281.60FasttextÂ±2048.41Tested on Intel i7-6700k and 32GB of RAM.UsageOutput either 0 (non-headline) and 1 (headline)fromheadline_detectorimportFasttextDetector,IndoBERTweetDetector,CNNDetectordetector=FasttextDetector.load_from_scenario(1)data=detector.predict_text(["nama kamu siapa?","Kapolda Jatim Teddy Minahasa Dikabarkan Ditangkap Terkait Narkoba  https://t.co/LD9X6VFaUR",])print(data)# output: [0, 1]detector=CNNDetector.load_from_scenario(3)data=detector.predict_text(["nama kamu siapa?","Kapolda Jatim Teddy Minahasa Dikabarkan Ditangkap Terkait Narkoba  https://t.co/LD9X6VFaUR",])print(data)# output: [0, 1]detector=IndoBERTweetDetector.load_from_scenario(5)data=detector.predict_text(["nama kamu siapa?","Kapolda Jatim Teddy Minahasa Dikabarkan Ditangkap Terkait Narkoba  https://t.co/LD9X6VFaUR",])print(data)# output: [0, 1]# 0 is non-headline# 1 is headlinePaperComing soon.
Package: headliner
Headliner is a sequence modeling library that eases the training andin particular, the deployment of custom sequence modelsfor both researchers and developers.
You can very easily deploy your models in a few lines of code. It was originally
built for our own research to generate headlines from news articles.
That’s why we chose the name, Headliner. Although this library was created internally to
generate headlines, you can also use it for other tasks like machine translations,
text summarization and many more.Read the documentation at:https://as-ideas.github.io/headliner/Headliner is compatible with Python 3.6+ and is distributed under the MIT license.