Saravanan666/pypi-org huggingface dataset:
Package: record3d
Record3D – Point Cloud Animation and Streaming: the accompanying library2022/08/16 Update: Added camera position streaming (introduced breaking changes).To be used with Record3D 1.7.2 and newer.2021/07/28 Update: Introduced support for higher-quality RGB LiDAR streaming.To be used with Record3D 1.6 and newer.2020/09/17 Update: Introduced LiDAR support. To be used with Record3D 1.4 and newer.This project provides C++ and Python libraries for theiOS Record3D appwhich allows you (among other features) to
live-stream RGBDvideo from iOS devices with TrueDepth camera to a computer via USB cable.PrerequisitesInstallCMake>=3.13.0and make sure it is inPATH.When on macOS and Windows, installiTunes.When on Linux, installlibusbmuxd(sudo apt install libusbmuxd-dev). It should be installed by default on Ubuntu.InstallingThe libraries are multiplatform — macOS, Linux and Windows are supported.PythonYou can install either viapip:python -m pip install record3dor build from source (run as admin/root):git clone https://github.com/marek-simonik/record3d
cd record3d
python setup.py installC++After running the following, you will find compiled static library in thebuildfolder and header files in theincludefolder.macOS and Linuxgit clone https://github.com/marek-simonik/record3d
cd record3d
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
make -j8 record3d_cpp
make install
# now you can link against the `record3d_cpp` library in your projectWindowsgit clone https://github.com/marek-simonik/record3d
cd record3d
md build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -G "Visual Studio 15 2017 Win64" ..
# Open the generated Visual Studio Solution (.sln) fil and build the "`record3d_cpp`" ProjectSample applicationsThere is a Python (demo-main.py) and C++ (src/DemoMain.cpp) sample project that demonstrates how to use the library to receive and display RGBD stream.Before running the sample applications, connect your iOS device to your computer and open the Record3D iOS app. Go to the Settings tab and enable "USB Streaming mode".PythonAfter installing therecord3dlibrary, runpython demo-main.pyand press the record button to start streaming RGBD data.C++You can build the C++ demo app by running the following (press the record button in the iOS app to start streaming RGBD data):macOS and Linuxgit clone https://github.com/marek-simonik/record3d
cd record3d
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
make -j8 demo
./demoWindowsgit clone https://github.com/marek-simonik/record3d
cd record3d
md build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -G "Visual Studio 15 2017 Win64" ..
# Open the generated Visual Studio Solution (.sln) file and run the "`demo`" Project
Package: recordbin
RecordBin PythonPython Client for PythonRecordBinInstallingpip install recordbinUsage Example>>> from recordbin import RecordBin
>>> recordbin = RecordBin('http://ww-recordbin.herokuapp.com', token='123')
>>> recordbin.post({'username': 'gtalarico'})Getting Posted RecordBy default records are posted asynchronously and responses
are Future objects.
To get the post response use theresult()method>>> future = recordbin.post({'username': 'gtalarico'})
>>> response = future.result()
>>> record = response.json()LicenseMITHistory0.1.1Alpha Release
Package: recordcapture
recordcapturerecordcapture is a library based on Desktop Duplication API, pillow, and pyaudio which provide multiple methods for capturing and recording Screen and Microphone.Usuage:import recordcapturesr=recordcapture.screenRecord()sr.start(seconds=30,filename=None,frame=30,bitrate=8000000,useGPU=False,countdown=5,echo=True)#Note: All Parameters are optionalseconds: total time to record the screen in secondsfilename: any filename eg: abc.mp4, if not provided, will take timestamp as default.frame: frame per second.bitrate: bit processed per unit of timeuseGPU: using gpu for enhanced the recording, if face issue the  put as Falsecountdown: countdown before start recordingecho: to print the event messagesar=recordcapture.micRecord()ar.start(seconds=30,filename=None,chunk=1024,channels=2,rate=44100,countdown=5,echo=True)#Note: All Parameters are optionalseconds: total time to record the screen in secondsfilename: any filename eg: abc.wav, if not provided, will take timestamp as default.chunk: chunk sizechannels: sound coming from pointsrate: sample ratecountdown: countdown before start recordingecho: to print the event messagesss=recordcapture.screenshot()ss.capture(countdown=5,filename=None,extension='png',echo=True)#Note: All Parameters are optionalcountdown: countdown before start recordingfilename: any filename eg: abc.png, if not provided, will take timestamp as default.extension: file extensionecho: to print the event messages
Package: recorder
recorderA simple audio recorder which is Based on PyAudioUsageinstallpip install recorderget device infoget all device infofromrecorderimportRecorderr=Recorder()print(r.get_device_info())get specified device infofromrecorderimportRecorderr=Recorder()print(r.get_device_info(index=0))recordrecord for 5 seconds and return the data as numpy arrayfromrecorderimportRecorderr=Recorder()np_data=r.record(5)print(np_data)record for 5 seconds and save the data to fileout.wavfromrecorderimportRecorderr=Recorder()r.record(5,output='out.wav')get wave data with queueget wave data from queue and print datafromrecorderimportRecorderr=Recorder()q=r.get_wave_queue()whileTrue:print(q.get())playplay a piece of soundfromrecorderimportRecorderRecorder.play('out.wav')closeclose the recorderfromrecorderimportRecorderr=Recorder()r.close()
Package: recorder-mock
recorder-mockallows to record interactions on patched Python objects and repeat the interactions when the patched object is no longer available.Installationpipinstallrecorder-mockUsagefrom recorder_mock import recorder_patch

@recorder_patch("httpx")
class ExampleTestCase(unittest.TestCase):
    def test_get_example_com_content():
        client = httpx.client()
        resp = client.get("example.com")
        return resp.contentFirst execution of the tests will hit the Internet and record the interactions.
Second test run won't hit the internet, recorded interactions will be repeated instead.Related projectsThis tool was inspired by:patchandMagicMockfromunittest.mockstandard library packageVCR.pypackage
Package: recOrder-napari
recOrderrecOrderis a collection of computational imaging methods. It currently provides QLIPP (quantitative label-free imaging with phase and polarization), phase from defocus, and fluorescence deconvolution.Acquisition, calibration, background correction, reconstruction, and applications of QLIPP are described in the followingE-Life Paper:Syuan-Ming Guo, Li-Hao Yeh, Jenny Folkesson, Ivan E Ivanov, Anitha P Krishnan, Matthew G Keefe, Ezzat Hashemi, David Shin, Bryant B Chhun, Nathan H Cho, Manuel D Leonetti, May H Han, Tomasz J Nowakowski, Shalin B Mehta, "Revealing architectural order with quantitative label-free imaging and deep learning," eLife 2020;9:e55502 DOI: 10.7554/eLife.55502 (2020).These are the kinds of data you can acquire withrecOrderand QLIPP:https://user-images.githubusercontent.com/9554101/271128301-cc71da57-df6f-401b-a955-796750a96d88.movhttps://user-images.githubusercontent.com/9554101/271128510-aa2180af-607f-4c0c-912c-c18dc4f29432.mp4What do I need to userecOrderrecOrderis to be used alongside a conventional widefield microscope. For QLIPP, the microscope must be fitted with an analyzer and a universal polarizer:https://user-images.githubusercontent.com/9554101/273073475-70afb05a-1eb7-4019-9c42-af3e07bef723.mp4For phase-from-defocus or fluorescence deconvolution methods, the universal polarizer is optional.The overall structure ofrecOrderis shown in Panel B, highlighting the structure of the graphical user interface (GUI) through a napari plugin and the command-line interface (CLI) that allows users to perform reconstructions.Software Quick Start(Optional but recommended) installanacondaand create a virtual environment:condacreate-y-nrecOrderpython=3.9
condaactivaterecOrderInstallrecOrder-napari:pipinstallrecOrder-napariOpennapariwithrecOrder-napari:napari-wrecOrder-napariFor more help, seerecOrder's documentation. To installrecOrderon a microscope, see themicroscope installation guide.DatasetSlidesand adatasetshared during a workshop on QLIPP and recOrder can be found on Zenodo, and the napari plugin's sample contributions (File > Open Sample > recOrder-napariin napari).
Package: recorder-utils
PrerequisiteMPI implementation such as openmpi or MPICHInstallInstall from sourcepip install -r requirements.txt
pip install .Or Install from pippip install recorder-utilsUsagerecorder2csv /path/to/your_trace_folder/   /path/to/output.csv/A csv trace file will be generated to the output file you specifiedTestUse the test file under test directory, the output will be in the data directoryExampleUnder Recorder-util directorypython3 test/test_convert_text.pyAPIRecorderReader:GM : RecorderMetadatafuncs : string[], utf-8records : *PyRecord[], range(): 0 - total_rank-1LMs : LocalMetadata[], range(): 0 - total_rank-1RecorderMetadata:total_ranks : c_intstart_ts : c_doubletime_resolution : c_doublets_buffer_elements : c_intts_compression_algo : c_intLocalMetadata:total_records : c_size_tnum_files : intfilemap : set()function_count : int[], share the index with Recorder.funcsPyRecord:tstart : c_doubletend : c_doublelevel : c_ubytefunc_id : c_ubytetid : c_intarg_count : c_ubyteargs_to_strs : string[], utf-8IntervalsCurrent intervals are taken from POSIX and MPIIO layers. They are stored in the dataframe that return by the functionbuild_offset_intervals. The intervals contain I/O records and correspondingfile_id, rank, function, offset, size, start time, and end time.
Package: recorder-viz
recorder-vizThis is a python package which contains tools for processingRecordertraces.Installationpip install recorder-vizVisualizationWe relie on a few libraries for visualization. Please install them first.Dependencies:pandas,bokehandprettytable.importrecorder_vizfromrecorder_vizimportRecorderReaderreader=RecorderReader("path/to/Recorder-traces-folder")recorder_viz.generate_report(reader,"output.html")Thegenerate_reportAPI will write out a HTML format visualization report.The visualization process can be slow for large traces. We recommend to use it only for small scale runs, e.g., < 128 ranks runs.Below are some example graphs generated from theFLASHtraces.Advanced UsagesTheRecorderReaderclass contains all infomration about the Recorder traces.classRecorderReader:self.GM:instanceofGlobalMetadataself.LMs:listofLocalMetadataobjects,oneforeachrankself.records:self.records[i]isalistofRecordobjectsofranki.GlobalMetadta,LocalMetadataandRecordare three Python wrappers of C structures.classLocalMetadata(Structure):self.total_records:intself.num_files:intself.filemap:set()self.function_count:[]classRecorderMetadata(Structure):_fields_=[("total_ranks",c_int),("start_ts",c_double),("time_resolution",c_double),("ts_buffer_elements",c_int),("ts_compression_algo",c_int),]classRecord(Structure):_fields_=[("tstart",c_double),("tend",c_double),("level",c_ubyte),("func_id",c_ubyte),("tid",c_int),("arg_count",c_ubyte),("args",POINTER(c_char_p)),]Here's an example on how to use the provided classes.fromrecorder_vizimportRecorderReaderreader=RecorderReader("path/to/Recorder-traces-folder")forrankinrange(reader.GM.total_ranks):LM=reader.LMs[rank]print("Rank:%d, Number of trace records:%d"%(rank,LM.total_records))
Package: recordinality
A Python implementation of theRecordinalitysketch for cardinality estimation and stream sampling. Inspired by C.
Scott Andreas’simplementation, but
powered by SipHash-2-4 rather than MurmurHash3. In particular, this
project uses two other libraries of mine:csiphashandcskipdict.Installationpip install recordinalityUsageYou can use the command-line application, which will read lines of text
incrementally from stdin, printing the stream’s cardinality (or a random
sample) once the pipe is closed:$ recordinality -k <sketch-size> [-h|--hash-key <hash-key>] [-s|--sample] < input-lines.txt
3574
$ cat input-lines.txt | sort -u | wc -l
3556SipHash allows the specification of a ‘secret key’ (used here as more of
a hash seed); if provided it should be either a 16-char ASCII string or
32-char hexadecimal string.You can also import theRecordinalityclass in Python:>>>fromrecordinalityimportRecordinality>>>sketch=Recordinality(size=512)>>>forobservationininput_observations:...sketch.add(observation)>>>print(sketch.cardinality())3574>>>print(sketch.k_sample)['strife','bragging','knight?',...]UnlicenseThis is free and unencumbered software released into the public domain.Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any means.In jurisdictions that recognize copyright laws, the author or authors of
this software dedicate any and all copyright interest in the software to
the public domain. We make this dedication for the benefit of the public
at large and to the detriment of our heirs and successors. We intend
this dedication to be an overt act of relinquishment in perpetuity of
all present and future rights to this software under copyright law.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 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.For more information, please refer tohttp://unlicense.org/
Package: record-ip-to-dnspod
Record machine’s ip to DNSpod viaDNSPod’s API.InstallationTo install:pip install record-ip-to-dnspodExample UsageCommand:record-ip-to-dnspod -c /path/record-ip.iniIf you wan’t install via pip, you can:git clone https://github.com/codeif/record-ip-to-dnspod.git
cd record-ip-to-dnspod && python -m record_ip_to_dnspod.bin -c /path/record-ip.iniConfig Exampleini文件:[record-ip]
log-path = record-ip.log
token = 1234,your-token-str
email = me@codeif.com
domain = example.com
sub-domain = test
; interface = eth0
; exclude-ips = 127.0.0.1,172.16.0.1Config Options必填配置项配置项说明log-path日志路径tokenToken, 例如：13490,6b5976c68aba5b14a0558b77c17c3932&format=jsonemail联系邮箱，用于API请求的User-Agent.domain域名， 例如： example.comsub-domain主机记录, 如 www，可选，如果不传，默认为 @可选配置项配置项说明interface只记录指定的网卡，例如: eth0excluet-ips不记录下面的ip， 比如’127.0.0.1,172.16.0.1’
Package: recordit-url-builder
A simple tool to generate recordit URLsUsagefrom recordit.url import URLBuilder
# or import recordit.url and use recordit.url.URLBuilder

url_builder = URLBuilder(
  "f33dd06d1cd1fb6e94504c767e5ccd9d0f7cd039",     # your client ID
  "6d85ffe45dbc37f6e47bc443f6079dc26f61b3df"      # your secret
)

url_builder.generate({
    "fps": 12,
    "encode": "none",
    "action_url": "http://example.com/123",
    "callback": "http://example.com/api/123",
    "start_message": "This is the initial message",
    "end_message": "This is the end message",
    "width": 1280,
    "height": 720
})

# => recordit:f33dd06d1cd1fb6e94504c767e5ccd9d0f7cd039-565fcfbfe0c2e0c59be5
9df7b3b73d42f564e6cc?fps=12&encode=none&action_url=http%3A%2F%2Fexample.com%
2F123&callback=http%3A%2F%2Fexample.com%2Fapi%2F123&start_message=This%20is%
20the%20initial%20message&end_message=This%20is%20the%20end%20message&width=
1280&height=720
Package: record-keeper
record-keeperInstallationpip install record-keeperThe Problem:When running machine-learning experiments, having more logged data is usually better than less. But adding new series of data to log can often require changes to your training code. When you want to log dozens of different series of data, your code starts to look awful.The Solution:Use RecordKeeper, and easily add loggable information when you write a new class. The example below is modified from thepytorch-metric-learninglibrary.First, create a list that contains the names of the attributes you want to record (self._record_thesein the example below).classBatchHardMiner(BaseTupleMiner):def__init__(self,**kwargs):super().__init__(**kwargs)self._record_these=["hardest_triplet_dist","hardest_pos_pair_dist","hardest_neg_pair_dist"]Then tell RecordKeeper the name of the list to read. RecordKeeper will log and save all the attributes described in the list. It'll search recursively too, if you have nested objects.fromtorch.utils.tensorboardimportSummaryWriterimportrecord_keeperasrecord_keeper_packagefrompytorch_metric_learningimportminersrecord_writer=record_keeper_package.RecordWriter(your_folder_for_logs)tensorboard_writer=SummaryWriter(log_dir=your_tensorboard_folder)record_keeper=record_keeper_package.RecordKeeper(tensorboard_writer,record_writer,["_record_these"])your_miner_dictionary={"tuple_miner":miners.BatchHardMiner()}# Then at each iteration of training:record_keeper.update_records(your_miner_dictionary,current_iteration)Now the attributes described in_record_these, (specifically,hardest_triplet_dist,hardest_pos_pair_dist, andhardest_neg_pair_dist) can be viewed on Tensorboard.These data series are also saved in sqlite and CSV format. If you only want to use Tensorboard, then pass in only a SummaryWriter, and vice versa.The dictionary that you pass intorecord_keeper.update_recordscan contain any number of objects, and for each one, RecordKeeper will check if the object has a "_record_these" attribute. As long as you're making your dictionaries programmatically, it's possible to add large amounts of loggable data without clogging up your training code. Seepytorch-metric-learningandpowerful-benchmarkerto see RecordKeeper in action.
Package: record-kit
record-kitA simple record toolkit generating human-readable data record in experiments.Installationpipinstallrecord-kitUsageSuppose you have an experiment script like this:importargparseparser=argparse.ArgumentParser()parser.add_argument('--lr',type=float)args=parser.parse_args()deftrain_ml_model():foriinrange(2):epoch,loss,acc=i,0.1,0.5Using record-kit to track these generated data is quite easy:fromrecord_kitimportRecorder,Record# use Recorder to track experiment dataimportargparseparser=argparse.ArgumentParser()parser.add_argument('--lr',type=float,default=0.1)args=parser.parse_args()deftrain_ml_model():foriinrange(2):epoch,loss,acc=i,0.1,0.5recorder.add_data(epoch,loss,acc)# save data# init Recorderrecorder=Recorder()# init Recorderrecorder.set_meta(args)# save arguments like hyperparametersrecorder.set_header('epoch','loss','acc')# specify table header# parse recordrecord=Record(recorder)# or record = Record('path/to/record')print(record.meta)print(record.data)output{'lr':0.1}epochlossacc00.00.100.511.00.080.9generated record in./records/record-timestamp.mdRecord FormatA typical record includes two sectionsMetaandData.# record-20201020-154912## Meta| key | value | type |
| :---: | :---: | :---: |
| lr | 0.1 | float |## Data| epoch | loss | acc |
| :---: | :---: | :---: |
| 0 | 0.1 | 0.5 |
| 1 | 0.08 | 0.9 |APIRecorderRecorder(file_name='record', records_dir='./records', with_timestamp=True)Initialize a Recorder instanceRecorder.set_meta(dict_like_object)Add meta info to the record. Note meta info can only be added once.
You may usedictorargparse.Namespace(return type ofparser.parse_args()) as its parameter.Recorder.set_header(*args)Specify header of data table in Data section. The header can only be added once.Recorder.add(*args)Add a data line to the table inDatasection.
The number of parameters in should be consistent withRecorder.set_header(*args)RecordRecord(Recorder_or_path_str)Load & parse recordRecord.meta -> dictGet meta info of record.Record.data -> pandas.DataFrameGet data table of record.
Package: recordLine
RecordLine--------RecordLine is a line data recorder!RecordLine is Fun```````````````::>>> import recordLine as rl>>> db = rl.load('test.db')>>> db.new('somthing data')True>>> db.show()[...,...,...,'somthing data']And Easy to Install```````````````````::$ pip install recordLineLinks`````* `project repo <https://github.com/amiralinull/recordLine/>`_
Package: record-msg
record_msgrecord message parse helper function. It needs to be used in combination withcyber_recordParser recordFirst read the record file throughcyber_record, thenrecord_msgprovides 3 interfaces to help parsing cyber record file.csv formatyou can useto_csvto format objects so that they can be easily saved in csv format.importcsvfromrecord_msg.parserimportto_csvf=open("message.csv",'w')writer=csv.writer(f)defparse_pose(pose):'''save pose to csv file'''line=to_csv([pose.header.timestamp_sec,pose.pose])writer.writerow(line)f.close()imageyou can useImageParserto parse and save images inoutput_path.fromrecord_msg.parserimportImageParserimage_parser=ImageParser(output_path='../test')fortopic,message,tinrecord.read_messages():iftopic=="/apollo/sensor/camera/front_6mm/image":image_parser.parse(message)# or use timestamp as image file name# image_parser.parse(image, t)lidaryou can usePointCloudParserto parse and save pointclouds inoutput_path.fromrecord_msg.parserimportPointCloudParserpointcloud_parser=PointCloudParser('../test')fortopic,message,tinrecord.read_messages():iftopic=="/apollo/sensor/lidar32/compensator/PointCloud2":pointcloud_parser.parse(message)# other modes, default is 'ascii'# pointcloud_parser.parse(message, mode='binary')# pointcloud_parser.parse(message, mode='binary_compressed')