Saravanan666/pypi-org huggingface dataset:
Package: sdr
sdrThesdrlibrary is a Python 3 package for software-defined radio (SDR).The goal ofsdris to provide tools to design, analyze, build, and test digital communication systems
in Python. The library relies on and is designed to be interoperable with NumPy, SciPy, and Matplotlib.
Performance is also very important. So, where possible, Numba is used to accelerate computationally-intensive
functions.Additionally, the library aims to replicate relevant functionality from MATLAB's Communications and
DSP Toolboxes.We are progressively adding functionality to the library. If there is something you'd like to see included
insdr, please open an issue on GitHub.Enjoying the library? Give us a :star: onGitHub!DocumentationThe documentation forsdris located athttps://mhostetter.github.io/sdr/latest/.InstallationThe latest version ofsdrcan be installed fromPyPIusingpip.python3 -m pip install sdrFeaturesView all available classes and functions in theAPI Reference.Digital signal processing: Finite impulse response (FIR) filter, FIR filter design,
infinite impulse response (IIR) filter, polyphase interpolator, polyphase decimator, polyphase resampler,
polyphase channelizer, Farrow arbitrary resampler, fractional delay FIR filter, FIR moving average,
FIR differentiator, IIR integrator, IIR leaky integrator, complex mixing, real/complex conversion.Sequences: Barker, Hadamard, Walsh, Zadoff-Chu.Modulation: Phase-shift keying (PSK), $\pi/M$ PSK, offset QPSK, rectangular pulse shape, half-sine pulse shape,
raised cosine pulse shape, root raised cosine pulse shape, Gaussian pulse shape, binary and Gray symbol mapping,
differential encoding.Synchronization: Numerically-controlled oscillator (NCO), loop filter, closed-loop phase-locked loop (PLL)
analysis, automatic gain control (AGC), phase error detector (PEDs).Measurement: Energy, power, voltage, Euclidean distance, Hamming distance, bit/symbol error rate,
error vector magnitude (EVM).Conversions: Between linear units and decibels. Between $E_b/N_0$, $E_s/N_0$, and $S/N$.Simulation: Binary symmetric channel (BSC), binary erasure channel (BEC), discrete memoryless channel (DMC),
additive white Gaussian noise (AWGN), frequency offset, sample rate offset, IQ imbalance.Link budgets: Channel capacity, free-space path loss, antenna gain.Data manipulation: Packing and unpacking binary data, hexdump of binary data.Plotting: Time-domain, raster, periodogram, spectrogram, constellation, symbol map, eye diagram,
bit error rate (BER), symbol error rate (SER), impulse response, step response, magnitude response, phase response,
phase delay, group delay, and zeros/poles.ExamplesThere are detailed examples published athttps://mhostetter.github.io/sdr/latest/examples/pulse-shapes/.
The Jupyter notebooks behind the examples are available for experimentation indocs/examples/.
Package: sdRDM
Software-Driven RDMWith Software-driven Research Data Management (sdRDM), you can confidently specify data models using verbose Markdown documents and effortlessly convert them into powerful Python objects that can be serialized into any data exchange format.🏎 FeaturesGenerate and maintain RDM APIs via readable specifications inMarkdownData Models defined in sdRDM can be exported toany formatLink your data model to any other data model and setupworkflows⚡️ Quick startGet started with by running the following command# Using PIPpython-mpipinstallsdRDMOr build by sourcegitclonehttps://github.com/JR-1991/software-driven-rdm.gitcdsoftware-driven-rdm
python3setup.pyinstall📖 Documentation and more examplesIn the making! 🐛📦 Other sdRDM-related repositoriesCode generator for GitHub Actions: Deposit your Markdown-based data model in a GitHub repository and automatically generate a Python API upon changes.Create a database from a Markdown-based data model: Use your data model to create a relational database and interact with it via a Python API.⚠️ LicensesdRDMis free and open-source software licensed under the MIT License.
Package: sdrdm_database
sdrdm-databaseThis is the sdRDM DB interface to create tables from a markdown model and insert/retrieve data from it.InstallationTo get started with the sdRDM DB interface, you can install it via pip:# Base installationpipinstallsdrdm_database# MySQLpipinstall"sdrdm_database[mysql]"# PostgreSQLpipinstall"sdrdm_database[postgres]"or directly from the GitHub repository:pipinstallgit+https://github.com/JR-1991/sdrdm-database.gitExamplesSetting up a MySQL database and add an EnzymeML modelSetting up a PostgreSQL database and add an EnzymeML modelDealing with nested data modelsQuery a MySQL database using GraphQLApplication: Building and working with an EnzymeML database
Package: sdrewire
Python tools for SDReWireThis repository contains Python tools forSDReWire.
Currently the command line utilitysdrewirectlis the only utility.Check if SDReWire devices are available:$ sdrewire list
Found the following devices:
Device: 101, Manufacturer: SliwaIO, Product: SDReWire v1.0, Serial: SDRW00004
Device: 104, Manufacturer: SliwaIO, Product: SDReWire v1.0, Serial: SDRW00003Muxing can be controlled using:$ sdrewire --serial SDRW00003 sdmux --ts
$ sdrewire --serial SDRW00003 sdmux --status
SD mux connected to: TS
$ sdrewire --serial SDRW00003 sdmux --dut
$ sdrewire --serial SDRW00003 sdmux --status
SD mux connected to: DUT
Package: sdrfcheck
sdrfcheckLibrary and tool to validate an sdrf (Sample and Data Relationship Format) for proteomics. The file format specification can be found here
(https://github.com/bigbio/proteomics-metadata-standard)How to use it:First you need to install the tool:pipinstallsdrfcheckerThen, you can use the tool by executing the following command:pythonsdrfchecker.pyvalidate-sdrf--sdrf_file{here_the_path_to_sdrf_file}
Package: sdr-hazards-classification
Service Difficult Report (SDR) hazards classification package:rocket: This is the source code for the SDR Classifier package that classifies potential aviation safety hazards from textual data.  The work is a collaboration between FAA and Boeing data scientist teamsVersion 0.1.0 out now!Check out the release notes here.DemoVirtual EnvironmentIt is highly recommended to use venv, virtualenv or conda python environments. Read more about creating virtual environments via venvhttps://docs.python.org/3/tutorial/venv.html#creating-virtual-environmentsBuild and pip install the whl file locallyRun the command in the root folder to create the whl file in thedistfoldergit clone https://github.com/Boeing/sdr-hazards-classification
python setup.py bdist_wheel
pip install ./distr/sdr_hazards_classification-0.1.0-py3-none-any.whlInstall sdr_hazards_classification from Pypi with pippip install sdr_hazards_classificationExample:airplane: Follow the code snippet below to test and call the prediction method from the Depressurization modelfrom sdr_hazards_classification import sdr_api
import pandas as pd

my_model = sdr_api.SdrInferenceAPI()

#test the prediction method
my_model.test_sdr_depressurization_predictions()

event_text = "Lost cabin pressurization at flight level 30000, cabin altitude warning horn sounded at 10000 feet. Unabel to control cabin pressure with outflow valve closed"
pred, probs = my_model.get_predictions([event_text])

df = pd.read_csv('./src/sdr_classifier/data/SDR_Example.csv')
records = df["Text"]
#pass in a record list for prediction
pred, probs = my_model.get_predictions(records)

df['Prediction'] = pred
df['Prob'] = probs

print(df.head(2))

print("Done")Contributing🛩️ Please follow thecontribution guideline
Package: sdr-helper
sdr_helperSoftware Defined Radio Streaming tortlsdr_helperwith Interface topyaudio_helperA recent push to the master branch now allows real-time SDR streaming from the RTL-SDR topyaudio_helper.This capability is made possible via the newasynchandawaitcapabilities of Python 3.7. For the details as to how this works you have to dig into the details found in the modulertlsdr_helper.pyand the examples found in the notebookrtlsdr_helper_streaming_sample.ipynb.This is just the beginning of making a complete SDR receiver possible in a Jupyter notebook. Not only is the receiver a reality, the algorithms that implement the receiver, in Python, can easily be coded by the user.To help develop demodulator algorithms a streaming code block interface standard, of sorts, is being developed this summer. The idea is to provide examples of how to write a simple Python class that will manage states in the DSP code that is inside theCallback Processblock of the block diagram. More details by the end of the summer is expected, along with another sample notebook.Authors@mwickert@andrewsmitty
Package: sdrialization
⠄⠄⠄⠄⠄⡇⠄⠄⠄⠄⠄⢠⡀⠄⠄⢀⡬⠛⠁⠄⠄⠄⠄⠄⠄⠄⠉⠻⣿⣿⣿⣽⣿⣿⣿⣿⣿⣿⣿⣿⣧⠄⠄⠙⢦
⠄⠄⠄⠄⠄⡇⠄⠄⠄⠄⢰⠼⠙⢀⡴⠋⠄⠄⠄⠄⠄⠄⠄⠄⠄⡠⠖⠄⠄⠙⠿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣯⣀⡀⠄⠄⠄⡀
⠄⠄⠄⠄⠄⡇⠄⠄⠄⠄⠄⠄⡴⠋⠄⠄⠄⠄⠄⠄⠄⠄⠄⢠⠞⠄⠄⠄⠄⠄⠄⠄⠄⠄⠉⠉⠉⠙⠋⠙⠋⠙⠻⠦⠤⣤⣼⣆⣀⣀⣀⣀⡀
⠄⠄⠄⠄⠄⢷⠄⠄⠄⠄⢠⠞⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⡰⠃⡄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠉⠉⠉
⠄⠄⠄⠄⠄⢸⡀⠄⠄⢠⠏⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⣰⠁⣸⠁⠄⠄⠄⠄⠄⠄⠄⠄⢀⠄⠄⡄
⠄⠄⠄⠄⠄⢀⣧⠄⢠⠏⠄⠄⠄⠄⠄⠄⠄⠄⠄⢀⢾⠃⡜⡿⠄⠄⠄⠄⠄⠄⠄⠄⣠⠋⢀⣼⠁⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠸⢾⣀⣠
⠄⠄⠄⢀⣠⢌⣦⢀⡏⠄⡄⠄⠄⢠⠃⠄⠄⠐⣶⡁⡞⡼⠄⣇⠄⠄⠄⠄⠄⠄⠄⡴⠁⢠⠎⢸⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢈⠝⠁
⠄⢀⠞⠉⠄⠄⠹⡼⠄⣼⠁⠄⠄⡏⠄⠄⢀⡞⠄⠈⣷⠇⠄⢻⠄⠄⠄⠄⠄⢐⣞⣀⣰⣃⣀⣸⠄⢀⠇⠄⠄⠄⠄⠄⠄⠄⠄⠄⠁⠄⠄⠄⠄⠄⢀
⢰⠋⠄⠄⠄⠄⢀⡇⢠⡏⠄⠄⢸⠄⠄⢀⠎⠄⠄⠄⡇⠄⠄⢸⡀⠄⠄⠄⢠⢾⢁⡜⠁⠄⠄⢸⠄⣸⠄⠄⠄⠄⠄⠄⡀⠄⠄⠄⠄⠄⠄⠄⢀⡴⠃
⡞⠄⠄⠄⠄⠄⢸⠄⡞⡷⠄⠄⡟⠄⢘⡟⠛⠷⠶⣤⣅⠄⠄⠄⣇⠄⠄⢠⠋⡧⠊⠄⠄⠄⠄⢸⢀⠇⠄⠄⠄⠄⠄⢰⠁⠄⠄⠄⠄⠄⢀⡴⠋
⢹⠄⠄⠄⠄⠄⡾⢰⠃⡇⠄⠄⡇⠄⡜⢀⣠⣤⠶⠞⠛⠁⠄⠄⠘⡄⡰⠃⠘⠱⣾⣟⡛⠛⠛⠛⡟⠂⠄⠄⠄⠄⠄⡎⠄⠄⠄⠄⣀⠴⡋
⠈⢳⠄⠄⠄⠄⡇⡼⠄⢻⠄⢠⡇⢸⠁⠈⠁⠄⠄⠄⠄⠄⠄⠄⠄⠈⠁⠄⠄⠄⠄⠙⠿⣶⣄⡰⠇⠄⠄⠄⠄⠄⡼⠄⠄⠄⡠⢾⣿⣆⢳
⣀⣬⠿⠷⠦⠤⣷⣇⡠⠾⡄⢸⣇⢸⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢹⠛⠂⠄⠄⠄⠄⣰⠁⠄⣀⣬⣷⠞⠛⠙⠛⢧⣤⣀
⠉⠄⠄⠄⠄⠄⢻⠄⠄⠄⢧⢸⢸⠘⡇⠄⠄⠄⠄⠄⠄⠄⠄⣠⠄⠄⠄⠄⠄⠄⠄⠄⠄⢠⠃⠄⠄⠄⠄⠄⣰⠃⣶⢉⠜⠋⠄⠄⠄⠄⠄⠄⠄⠈⢳
⠄⠄⠄⢀⣤⡀⢸⠄⠄⠄⠈⢿⠄⠄⣿⣆⠄⠄⠄⠄⠄⠄⠄⡟⣧⠄⠄⠄⠄⠄⠄⠄⡴⠃⠄⠄⠄⡠⠊⡰⡗⠋⡰⡼⠃⠄⠄⠄⠄⠄⠄⠄⠄⠄⢨
⠄⢀⡔⠉⠄⠙⢦⠄⠄⠄⠄⢸⡀⢰⡏⠈⠳⣄⠄⠄⠄⠄⠄⠉⠁⠄⠄⠄⠄⠄⢀⡞⠁⠄⢀⣤⠎⠄⡔⣡⠃⢰⡇⣹⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢼
⣰⠋⠄⢀⣴⣖⠒⠓⡆⠄⠄⠈⣇⣿⣿⠄⢸⠹⡷⢄⠄⠄⠄⠄⠄⠄⠄⠄⠄⣠⠋⠄⢀⣴⣿⠏⠠⠊⣴⡏⢠⢻⡇⢹⡆⠄⠄⠄⠄⠄⣷⠄⠄⣰⠋
⡇⠄⣰⣿⣿⣿⠒⠋⣛⣄⠄⠄⣹⢸⠈⢧⠸⡄⠹⣄⠙⠶⢶⣶⣶⣶⣶⡶⢾⠃⠄⡴⢋⡾⠋⣀⡴⣞⡝⡰⠃⠄⡇⡸⠉⠳⣄⣀⣀⣀⣿⣦⠞⠁
⢷⢰⣿⣿⣿⣿⠄⠈⠁⠈⡇⠄⡏⢸⠄⠈⠓⢧⣀⣈⣤⡤⠖⠛⠉⠁⠄⢡⠃⢠⡞⠓⠚⠓⠚⣳⡞⠈⠘⠁⠄⠄⢹⡇⠄⠄⠄⠈⠉⠁⠸⣷⣀⣀⣀
⢸⣿⣿⣿⣿⣿⠄⣿⣁⠜⠁⢸⡇⢸⣄⣀⡀⠘⢦⡀⠄⠄⠄⠄⠄⠄⢀⠏⡴⡻⠄⠄⠄⠠⣎⠹⡄⠄⢀⣀⣤⣤⣀⠁⠄⠄⠄⠄⠄⠄⠄⠈⢻⣿⣿
⢸⣿⣿⣿⣿⣿⡇⢸⠄⠄⢀⡴⡇⠈⡇⠈⣩⠗⠒⣵⠆⠄⠄⠄⠄⠄⢸⡞⢰⠃⢀⠄⣀⡰⠟⠒⠒⡿⠉⠄⠄⠄⠈⠑⣄⠄⠄⠄⠄⠄⠄⠄⠈⢿⣿
⣿⣿⣿⣿⣿⣿⣷⠎⠄⢠⠏⠄⠹⣄⢣⢠⠃⠄⠄⢤⠤⠄⠄⠠⠤⢶⡏⠄⡎⢠⠞⠋⠁⠄⠄⠄⣸⠁⠄⠄⠄⠄⠄⠄⠈⣧⠄⠄⠄⠄⠄⠄⠄⠄⠻
⣿⣿⣿⣿⣿⣿⣃⡀⢠⠏⠄⠄⠄⠄⣨⠇⠄⣠⠴⠚⠁⠄⠄⠄⠄⠈⡇⢰⠃⠄⠄⠄⠄⠄⠄⢰⠇⠄⠄⠄⠄⠄⠄⠄⠄⢹⡀
⣿⣿⣿⣿⣿⡿⢉⣇⡎⠄⠄⠄⠄⢰⠇⠄⢨⠇⠄⠄⠄⠄⠄⠄⠄⠄⠘⢾⡀⠄⠄⠄⠄⠄⠄⡞⢀⠄⠄⠄⠄⠄⠄⠄⠄⢸⡇
Package: sdriving
Social DrivingEmergent Road Rules In Multi-Agent Driving EnvironmentsFor autonomous vehicles to safely share the road with human drivers, autonomous vehicles must abide by specific "road rules" that human drivers have agreed to follow. "Road rules" include rules that drivers are required to follow by law -- such as the requirement that vehicles stop at red lights -- as well as more subtle social rules -- such as the implicit designation of fast lanes on the highway. In this paper, we provide empirical evidence that suggests that -- instead of hard-coding road rules into self-driving algorithms -- a scalable alternative may be to design multi-agent environments in which road rules emerge as optimal solutions to the problem of maximizing traffic flow. We analyze what ingredients in driving environments cause the emergence of these road rules and find that two crucial factors are noisy perception and agents' spatial density. We provide qualitative and quantitative evidence of the emergence of seven social driving behaviors, ranging from obeying traffic signals to following lanes, all of which emerge from training agents to drive quickly to destinations without colliding. Our results add empirical support for the social road rules that countries worldwide have agreed on for safe, efficient driving.InstallationStable Release version is available through pippip install sdrivingAlternatively you can install using the latest (unreleased) version usingpip install git+https://github.com/fidler-lab/social-driving.gitNuscenes MapsPreprocessednuScenes Mapsare providedhere, with the tagged release of this software. If you use these maps in your research consider citing thenuScenes Paper.Questions/RequestsPlease file an issue if you have any questions or requests about the code or the paper. If you prefer your question to be private, you can alternatively email me atavikpal@cse.iitk.ac.in.CitationIf you found this codebase useful in your research, please consider citing@misc{pal2020emergent,
    title={Emergent Road Rules In Multi-Agent Driving Environments}, 
    author={Avik Pal and Jonah Philion and Yuan-Hong Liao and Sanja Fidler},
    year={2020},
    eprint={2011.10753},
    archivePrefix={arXiv},
    primaryClass={cs.LG}
}
Package: sds
A library which implements the main variants of Stochastic Diffusion
Search (SDS), and provides a convenient front end.Stochastic Diffusion Search (SDS) is a generic population-based search method.
SDS agents perform cheap, partial evaluations of a hypothesis (a candidate
solution to the search problem). Hypotheses with the potential to be strong
solutions are then diffused through the swarm through direct one-to-one
communication. As a result of the diffusion mechanism, high-quality solutions
can be identified from clusters of agents with the same hypothesis.This is a library used during the writing of my PhD thesis, full documentation
and code are both published online.SDS has a Scholarpedia page:http://www.scholarpedia.org/article/Stochastic_diffusion_searchA list of papers written on SDS can be found in the Stochastic Diffusion
Search paper repository, maintained by the author of this module:http://aomartin.ddns.net/sds-repository/publications.html
Package: sds011lib
sds011libsds011libis a fully-typed, nearly-complete, python 3.8+ library for interacting with the SDS011 Air Quality Sensor.The SDS011 is a small, low-cost sensor created bywww.inovafitness.com, used to measure particulate matter in the air.  It
can measure both PM 2.5 and PM10 values simultaneously, and connects to devices over a serial port, or via USB with an
included adaptor.The full documentation is available athttps://timorme.github.io/sds011lib/Installationpip install sds011libQuickstartfromsds011libimportSDS011QueryReaderfromserialimportSerial# Setup a query-mode reader on /dev/ttyUSB0sensor=SDS011QueryReader('/dev/ttyUSB0')# Read some data!aqi=sensor.query()print(aqi.pm25)print(aqi.pm10)# Put the device to sleepsensor.sleep()# Wake it back upsensor.wake()
Package: sd-sdk-python
sd-sdk-pythonThis module is a Python helper module for the Sound Designer SDKThis Python module depends on a copy of the Sound Designer SDK being accessible on your computer. Make sure you have unzipped the Sound Designer SDK somewhere and then set the environment variableSD_SDK_ROOTto the root folder of the unzipped SDK, or to the path containing the Windows binaries (.dlls), Python module (sd.pyd), andsd.configfile.To test whether or not this module can resolve a valid Sound Designer SDK, you can run the following commands:importsd_sdk_pythonprint(sd_sdk_python.get_product_manager().Version)
Package: sd-server
Stable Diffusion Google Colab FastAPI ServerNote: This is a pretty hacky server / client interface for generic Stable Diffusion pipelines using diffusers. It's not made for production use and hasn't really been optimized completely.InstallationFrom pip:pipinstallsd-serverFrom source:gitclonegit@github.com:shyamsn97/stable-diffusion-server.gitcdstable-diffusion-server/
pythonsetup.pyinstallStable Diffusion Server + Client Interface -- Simple UsageHere we create a simple server hosting the standardStableDiffusionPipeline. The client takes in**kwargsthat should be the arguments passed into the__call__function from the pipeline. For instance, theStableDiffusionPipeline__call__method can be found:https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L185.hostandportcan be specified in thestartmethod for generic hosting.fromsd_serverimportDiffusersServer,DiffusersClientfromdiffusersimportStableDiffusionPipelineSTABLE_DIFFUSION_PATH="runwayml/stable-diffusion-v1-5"# this can be a local pathpipeline_kwargs={"revision":"fp16","torch_dtype":torch.float16}device=torch.device('cuda')server=DiffusersServer.create(pretrained_path=STABLE_DIFFUSION_PATH,pipeline_cls=StableDiffusionPipeline,pipeline_kwargs=pipeline_kwargs,enable_attention_slicing=True,device=device)url=server.start(host="127.0.0.1",port=8000)# url -- either remote or local# on another host / terminalclient=DiffusersClient(url)responses=client(prompt='a photo of an astronaut riding a horse on mars',num_images_per_prompt=4)# this should return a list of imagesServing from Google ColabUsing the server in Google Colab requires anngrokaccount, and needs your ngrok auth tokenhttps://dashboard.ngrok.com/get-started/your-authtokento be passed to the server. Note: Ngrok basically opens a tunnel from a dev machine to the cloud, which means its not really that secure, and should be used at your own risk. Read more here:https://stackoverflow.com/questions/36552950/is-ngrok-safe-to-use-or-can-it-be-compromisedNGROK_AUTH_KEY="your auth key from https://dashboard.ngrok.com/get-started/your-authtoken"...# imports from aboveserver=DiffusersServer.create(pretrained_path=STABLE_DIFFUSION_PATH,pipeline_cls=StableDiffusionPipeline,pipeline_kwargs=pipeline_kwargs,enable_attention_slicing=True,device=device)url=server.start(ngrok_auth_token=NGROK_AUTH_KEY)# on another hostclient=DiffusersClient(url)responses=client(prompt='a photo of an astronaut riding a horse on mars',num_images_per_prompt=4)# this should return a list of images
Package: sdsheets
ObjetivoLib para recuperar informações de planilhas do Google Spreadsheets através de APIUtilizaçãoHabilitar a API do Google Spreadsheets no console do GCP > APIs & Services > Libraries > Google Sheets API > EnableCriar uma key no console do GCP para autenticação na API através de IAM & Admin > Service Accounts > Create Key
2.1. Baixar o arquivo no formato JSON e armazenar em uma das pastas do projetoInstanciar a classe Sheets, informando 2 parâmetros:keyPath: Caminho e nome do arquivo que contém a chave de acesso para a API do Google Sheets
Exemplo: 'credentials/project-0456d0f0cd6a.json'spreadsheetId: Id da planilha que será consultada
Exemplo: '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms'Executar o método getRangeData, passando como parâmetro o range de células que deseja recuperar.Exemplo:res = getRangeData('Class Data!A2:E')RequisitosInstalar as libs abaixo:pip install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlibpip install oauth2clientManutençãoApós executar o clone deste código, executar o comando abaixo, para baixar todas as dependências:make install
Package: sdsim
sdsimstable diffusion model similarity calculatiororiginal:https://huggingface.co/JosephusCheung/ASimilarityCalculatiormodified:https://gist.github.com/toriato/87db2b3cbe9863be43b63ba10cd610adpackaging: hereInstallpipinstallsdsimUsagesdsimanimefull-latest.ckptACertainModel.safetensorssdsim-nv-jresult.jsonanimefull-latest.ckptACertainModel.safetensors❯sdsim--help
usage:sdsim[-h][-jJSON][-sSEED][-nv]basetargets[targets...]positionalarguments:basetargets

optionalarguments:-h,--helpshowthishelpmessageandexit-jJSON,--jsonJSON-sSEED,--seedSEED-nv,--no-verbosefromsdsimimportsimilaritymodel1="animefull-latest.ckpt"model2="ACertainModel.safetensors"model3="AbyssOrangeMix2_nsfw.safetensors"result=similarity(model1,[model2,model3],verbose=True)
Package: sdsort
sdsortSorts methods within python classes according to the step-down rule, as described inRobert C. Martin'sClean Code.
More concretely, methods are ordered in a depth-first-traversal order of the dependency tree.Installationpip install sdsortUsageTo target individual files, run thesdsortcommand, followed by the paths to the files that should be sorted:sdsort <file_1> <file_2>To sort all*.pyfiles in a directory, and all of its subdirectories, run thesdsortcommand followed by the directory path:sdsort <directory_path>MaturityIt's early days. Consider this an alpha for now.
Package: sdss
Author:Behrouz SafariLicense:MITsdssA python package for retrieving and analysing data from SDSS (Sloan Digital Sky Survey)InstallationInstall the latest version ofsdssfromPyPI:pip install sdssRequirements arenumpy,requests,Pillow,matplotlib,pandasandastropy.
Versions before 1.0.0 are not dependent onastropy.Quick startLet's create a Region:fromsdssimportRegionra=179.689293428354dec=-0.454379056007667reg=Region(ra,dec,fov=0.033)To see the image:reg.show()To see the image in threegrifilter bands (green, red, infrared) separately:reg.show3b()To find nearest objects:df_obj=reg.nearest_objects()To find nearest objects with spectrum:df_sp=reg.nearest_spects()Photometry exampleLet's download a frame, in fits and jpg, retrieve all of its objects.:fromsdss.photometryimportframe_filename,obj_frame_url,\download_file,unzip,get_df,df_radec2pixelobjid=1237646587710014999zip_file='data/'+frame_filename(objid)+'.fits.bz2'fits_file=zip_file[:-4]jpg_file=fits_file.replace('-r-','-irg-').replace('fits','jpg')zip_url=obj_frame_url(objid,'r')download_file(zip_url,'data/')unzip(zip_file)jpg_url=obj_frame_url(objid,'irg',jpg=True)download_file(jpg_url,'data/')df=get_df(objid)df=df_radec2pixel(df=df,fits_file=fits_file)df.to_csv('data/COMP.csv',index=False)Now we can plot our target image:importpandasaspdimportmatplotlib.pyplotaspltfromsdss.photometryimportframe_filename,obj_from_jpgobjid=1237646587710014999jpg_file='data/'+frame_filename(objid).replace('-r-','-irg-')+'.jpg'df=pd.read_csv('data/COMP.csv')img=obj_from_jpg(jpg_file=jpg_file,df=df,objid=objid)fig,ax=plt.subplots()ax.imshow(img)plt.show()Let's find the best apparture:fromsdss.photometryimportfluxdata=img[:,:,0]half=data.shape[0]//2center=(half,half)ls_r_star=[2,3,4,5,6,7,8,9,10,11,12]ls_background=[]ls_real_flux=[]forr_starinls_r_star:background,real_flux=flux(data,center,r_star)ls_background.append(background)ls_real_flux.append(real_flux)fig,ax=plt.subplots()ax.scatter(ls_r_star,ls_real_flux,c='b')ax.set_xlabel('R star')ax.set_ylabel('Sky subtracted flux')plt.grid()plt.show()See more examples atastrodatascience.net
Package: sdss-access
sdss_accessThis products allows for dynamically building filepaths to SDSS data products hosted on the Science Archive Server (SAS).  Filepaths
are dynamically constructed given a minimal name and set of keywords to be substituted via a string templating system.  Data products
can also be downloaded programmatically using anAccessclass which provides streaming downloads viarysncorcurldepending on your OS. See the full documentation athttp://sdss-access.readthedocs.io/en/latest/Developer InstallTo installsdss_accessfor development locally:git clone https://github.com/sdss/sdss_access
cd sdss_acccess
pip install -e ".[dev,docs]"Build Sphinx DocsWithin the top level repo directory, run thesdsstoolscommands:# build the Sphinx documentation
sdss docs.build

# open the docs locally in a browser
sdss docs.showDocumentation is automatically built and pushed to Read The Docs.TestingTests are created usingpytest.  Navigate to thetestsdirectory from the top level and run withpytest.cd tests
pytestCreating ReleasesNew releases ofsdss-accessare created automatically, and pushed toPyPi, when new tags are pushed to Github.  See theCreate ReleaseGithub Action andReleasesfor the list.New tag names follow the Python semantic versioning syntax, i.e.X.Y.Z.Useful linksGitHub:https://github.com/sdss/sdss_accessDocumentation:https://sdss-access.readthedocs.orgIssues:https://github.com/sdss/sdss_access/issues
Package: sdss-actorcore
actorcoreProvides core services used by most actors.actorcoreandopscoreprovide direct dependencies for the actors, whileactorkeysprovides the definitions of standard messages that will be broadcast by each actor.InstallationTo install usingpippip install sdss-actorcoreTo install from sourcegit clone git@github.com:sdss/actorcore
cd actorcore
pip install .
Package: sdss-araviscam
araviscamFLIR Blackfly S GigE camera reader for the SDSS-V LVM telescopePurposeA python class subclassed fromsdss/basecamto read monochrome images ofFLIRBlackfly S GigE cameras.
It uses theAravisC-library which is an interface toGenICamcameras. As such it might also be used to read a more general class of GenICam cameras.Developped for the acquisition and guider cameras of the Local Volume Mapper (LVM) instrument of the 5th generation of the telescopes of theSloan Digital Sky survey(SDSS-V).See Alsothis projectbaslerCammantacamflicamera