How to start using types in Python with mypy
0 likes85 views
This document provides an overview of using type annotations in Python to enable static type checking. It demonstrates how to annotate basic types like integers, strings, and lists. It also shows how to define type aliases, use optionals, create generic functions, use union types, and annotate callables. The goal is to add type safety to Python code and catch errors earlier using the static type checker Mypy.
1 of 23
Download to read offline
![Let’s prepare some 🍔
def make_hamburger(meat, number_of_meats):
return ["bread"] + [meat] * number_of_meats + ["bread"]
print(make_hamburger("BEEF", 2))
# ['bread', 'BEEF', 'BEEF', 'bread']](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-12-320.jpg)
![class MyTest(unittest.TestCase):
def test_make_hamburger_returns_list(self):
self.assertTrue(isinstance(make_hamburger("beef", 2), list))
def test_empty_make_hamburger_returns_breads(self):
self.assertEqual(make_hamburger(None, 0), ['bread', 'bread'])
def test_invalid_make_hamburger_raises(self):
with self.assertRaises(TypeError):
make_hamburger()
Unit testing?](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-13-320.jpg)
![from typing import List
def make_hamburger(meat: str, number_of_meats: int) -> List[str]:
return ["bread"] + [meat] * number_of_meats + ["bread"]
The `typing`module](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-14-320.jpg)
![from typing import List
Hamburger = List[str]
def make_hamburger(meat: str, number_of_meats: int) -> Hamburger:
return ["bread"] + [meat] * number_of_meats + ["bread"]
Type Alias](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-15-320.jpg)
![from typing import List, Optional
Hamburger = List[str]
Extras = Optional[List[str]]
def make_hamburger(meat: str, number_of_meats: int, extras: Extras) -> Hamburger:
if extras:
return ["bread"] + extras + [meat] * number_of_meats + ["bread"]
else:
return ["bread"] + [meat] * number_of_meats + ["bread"]
print(make_hamburger("Beef", 2, ['tomatoes', 'pickles']))
# ['bread', 'tomatoes', 'pickles', 'Beef', 'Beef', 'bread']
Optionals 🍅](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-16-320.jpg)
![from typing import TypeVar, List
T = TypeVar("T", int, List[str])
def generic_add(x: T, y: T) -> T:
return x + y
Generics ](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-17-320.jpg)
![x1: int = 5
y1: int = 2
print(generic_add(x1, y1)) # 7
x2: List[str] = ["Hello"]
y2: List[str] = ["World"]
print(generic_add(x2, y2)) # ['Hello', 'World']
x3: str = "foo"
y3: str = "bar"
print(generic_add(x3, y3)) # mypy error: Value of type variable "T" of
"generic_add" cannot be "str"
Generics ](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-18-320.jpg)
![from typing import Union
Number = Union[float, int]
def union_add(x: Number, y: Number) -> Number:
return x + y
Union Types](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-19-320.jpg)
![x1: int = 5
y1: float = 2.5
print(union_add(x1, y1))
# 7
x2: int = 2
y2: str = "1"
print(union_add(x2, y2))
# error: Argument 1 to "union_add" has incompatible type "str";
expected "Union[float, int]"
# error: Argument 2 to "union_add" has incompatible type "str";
expected "Union[float, int]"
Union Types](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-20-320.jpg)
![from typing import Callable
def sum_and_process(a: int, b: int, callback: Callable[[int], bool]) -> bool:
total = a + b
return callback(total)
def is_positive(val: int) -> bool:
return val > 0
output = sum_and_process(5, 2, is_positive)
print(output)
# True
Callables](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-21-320.jpg)
Ad
Recommended
Probabilistic retrieval model
Probabilistic retrieval modelbaradhimarch81 The document discusses probabilistic retrieval models in information retrieval. It introduces three influential probabilistic models: (1) Maron and Kuhns' 1960 model which calculates the probability of relevance based on historical user data; (2) Salton's model which estimates the probability of term occurrence in relevant documents; (3) A model that ranks documents by the probability of relevance and considers retrieval as a decision between costs of retrieving non-relevant vs. not retrieving relevant documents. The document provides background on the development of probabilistic IR models and challenges of estimating probabilities for evaluation.
6th commandment
6th commandmentSlater Morilla The document discusses Catholic teachings on the sixth commandment regarding chastity and sexual morality. It addresses topics like lust, masturbation, pornography, prostitution, fornication, homosexuality, child abuse, rape, and artificial birth control. The key messages are that sexuality is intended for marriage between a man and woman, open to creating life; any other uses violate chastity and human dignity.
Digital library technologies
Digital library technologies Shriram Pandey This document discusses the components and technologies of digital libraries. It describes the key components as selection and acquisition, organization through metadata assignment, indexing and storage in a repository, and search and retrieval via a digital library website. It then associates various technologies with these components, such as metadata standards, document formats, repository systems like DSpace and Fedora, and semantic technologies.
Basics of Information Sources in Reference Services
Basics of Information Sources in Reference ServicesAllana Delgado The document discusses different types of information sources, including primary sources which present original information, secondary sources which analyze and interpret primary sources, and tertiary sources which compile and summarize information from primary and secondary sources. It provides examples of different fact-finding sources like encyclopedias, dictionaries, and biographical sources. Controlled vocabularies and bibliographies help users access and direct them to relevant information sources.
Images of pastoral care
Images of pastoral careRev. Stacy Burdick This document discusses several concepts from pastoral care, including:
1) It describes patients sharing painful stories with chaplains about abuse, mental illness, and a desire for justice from God.
2) It discusses seeing a person as a "living human document" or "living human web" and understanding their experiences from multiple dimensions.
3) It explores the challenges caregivers may face in listening empathetically without becoming detached, and how exercising courage to enter another's suffering is important in pastoral care.
Static type checking in python
Static type checking in pythonSebastian Wagner The document discusses static typing in Python, highlighting the differences between static and dynamic typing and the benefits of using type annotations, particularly in large or complex projects. It covers practical syntax examples, including function definitions, variable types, and the use of generics, while also addressing the limitations of static typing. Tools such as mypy are mentioned for type checking and improving code quality, along with methods for handling legacy code.
Types my way: Static Typing in Python
Types my way: Static Typing in PythonJoe Cabrera This document discusses different approaches to typing in Python, including dynamic typing, static typing, and duck typing. It provides examples of using type hints and annotations in Python to indicate the expected types of function arguments and return values. Key approaches covered include using type comments for older Python versions, composite types like lists and dictionaries, optional types, unions, type aliases, and callable types. Coming features mentioned include annotations in Python 4.0 and various type checkers.
Type hints Python 3
Type hints Python 3Piotr Pałkiewicz The document discusses type hints in Python 3, which allow specifying the types of function parameters and return values to enable type checking without changing runtime behavior. It provides examples of basic type hints like int and str, generic types like List and Dict, Callable for functions, NamedTuple for named tuples, overloading functions based on type, and using dataclasses to define classes from annotated fields. While type hints do not affect runtime, they allow catching errors earlier during development and improve code readability, refactoring safety, and documentation.
Python Tutorial
Python TutorialEueung Mulyana This document provides an overview of NumPy, the core library for scientific computing in Python. It discusses NumPy arrays, which provide a grid of values that are all of the same type and indexed by tuples of integers. NumPy arrays can be initialized from nested lists and accessed using square brackets. NumPy also provides functions to create arrays filled with zeros, ones, random values, or a constant. The document covers slicing NumPy arrays to extract subarrays, and integer array indexing to construct arbitrary arrays from another array's data. It demonstrates how slicing returns views into the original data, while integer indexing allows selecting elements in any order.
Python_Cheat_Sheet_Keywords_1664634397.pdf
Python_Cheat_Sheet_Keywords_1664634397.pdfsagar414433 This document provides a cheat sheet on Python keywords and basic data types. It lists common Python keywords like False, True, and, or, not, break, continue, class, def, if, else, for, while, in, is, None, lambda, and return along with code examples. It also covers basic data types like Boolean, integer, float, string, list, set, dictionary, and complex data types like classes. It provides examples of using lists, sets, dictionaries, classes and functions in Python.
Python_Cheat_Sheet_Keywords_1664634397.pdf
Python_Cheat_Sheet_Keywords_1664634397.pdfsagar414433 This document provides examples and descriptions of Python keywords and basic data types. It discusses keywords like False, True, and, or, not, break, continue, class, def, if, elif, else, for, while, in, is, None, lambda, and return. It also covers basic data types like integers, floats, strings, lists, sets, dictionaries, and Boolean values. It provides code examples to demonstrate the usage of these keywords and data types in Python.
FIot_Unit-3 fundAMENTALS OF IOT BASICS.pptx
FIot_Unit-3 fundAMENTALS OF IOT BASICS.pptxssuser0b643d This document is an introductory guide to Python programming covering installation, data types, control flow, functions, and data structures. It highlights Python's general-purpose nature, ease of learning, and broad library support. The document includes examples of basic operations and constructs in Python, making it suitable for beginners in programming.
Type hints in python & mypy
Type hints in python & mypyAnirudh This document discusses type hints in Python, including their purpose, implementation, and advantages such as improved code readability and early bug detection. It highlights the optional nature of type hints, which support gradual typing, and explains how various type checkers like mypy work alongside them. Additionally, it covers structural subtyping introduced by PEP 544 and provides examples and references related to the subject.
unit 1.docx
unit 1.docxssuser2e84e4 This document provides an overview of Python data types including numeric, string, sequence, mapping, boolean, and set data types. It describes the main classes for each data type such as int, float, complex for numeric types, str for strings, list, tuple, range for sequences, dict for mappings, bool for booleans, and set, frozenset for sets. It includes examples of defining variables of each data type and using functions like type() and isinstance() to check the data type. It also summarizes key aspects of each data type like how they can be indexed, sliced, concatenated, and repeated.
BUILDING IoT WITH ARDUINO & RASPBERRY PI
BUILDING IoT WITH ARDUINO & RASPBERRY PImanohar011101110 The document provides a comprehensive introduction to Python as a programming language, covering its basic features, data types, and system setup on different operating systems. It discusses various programming constructs including functions, control flow statements, and data structures such as lists, tuples, and dictionaries. Furthermore, it highlights Python's ease of use, extensibility, and broad library support, making it suitable for both beginner and advanced programming in cloud computing.
Tip Top Typing - A Look at Python Typing
Tip Top Typing - A Look at Python TypingPatrick Viafore The document discusses Python's typing system, highlighting the importance of types in conveying intent to developers and aiding in error detection. It covers topics such as primitive vs. composite types, user-defined types, type hinting, and generics, illustrating these concepts with examples. It emphasizes the role of types in both data representation and operational capabilities, along with the use of protocols and type restrictions.
User-Defined Types.pdf
User-Defined Types.pdfPatrick Viafore The document discusses the importance of creating a robust and maintainable codebase to facilitate collaboration among developers, focusing on user-defined types, data classes, and invariants. It emphasizes clear communication through code and the responsibilities of developers to minimize future errors and misunderstandings. The talk also explores software design principles, such as inheritance and the Liskov substitution principle, to enhance code quality and coherence.
Type Annotations in Python: Whats, Whys and Wows!
Type Annotations in Python: Whats, Whys and Wows!Andreas Dewes The document discusses type annotations in Python. It explains why type annotations are useful for finding bugs, provides a history of type hints in Python from PEP 3107 to PEP 544, and demonstrates three approaches to adding type hints: inline annotations, type comments, and stub files. It also analyzes real-world usage of type hints by checking over 100 popular Python projects on GitHub and discusses additional uses for annotations beyond type checking.
Domain Driven Design Made Functional with Python
Domain Driven Design Made Functional with Python Jean Carlo Machado This document discusses using domain modeling with types in Python using the static type checker Mypy. It motivates the use of types for domain-driven design and functional programming concepts. It then provides examples of building blocks for Mypy's type system algebra, including simple values with new types, combinations of values, modeling choices with unions, type functions, classes, generics, and putting the concepts together in a workflow. It also discusses limitations of Mypy and resources for further learning. The overall goal is to leave the reader inspired to learn more about applying type systems to domain modeling.
A tour of Python
A tour of PythonAleksandar Veselinovic The document provides a comprehensive overview of Python programming, detailing its syntax, data types, functions, classes, and modules. It covers essential programming concepts such as operators, expressions, control flow, and debugging techniques. Additionally, the document discusses advanced topics like context managers, decorators, and exception handling, along with practical examples and code snippets.
An overview of Python 2.7
An overview of Python 2.7decoupled This document provides an overview of the Python programming language. It covers topics such as syntax, types and objects, operators and expressions, functions, classes and object-oriented programming, modules and packages, input/output, and the Python execution environment. It also discusses generators and iterators versus regular functions, namespaces and scopes, and classes in Python.
Robust Python.pptx
Robust Python.pptxPatrick Viafore The document discusses how to write robust Python code that will be maintainable for future collaborators. It emphasizes communicating intent through deliberate choices in code abstractions like enums, data classes, classes, and inheritance. These choices should make it hard for developers to introduce errors and easy to understand the constraints of the system. The goal is to minimize future friction and enable collaborators to focus on delivering value rather than debugging issues.
2 + 2 = 5: Monkey-patching CPython with ctypes to conform to Party doctrine
2 + 2 = 5: Monkey-patching CPython with ctypes to conform to Party doctrineFrankie Dintino The document outlines methods for modifying Python's built-in integer addition behavior using ctypes and monkey patching, particularly to change the result of 2 + 2 to 5. It discusses challenges related to type errors and peephole optimization in Python's bytecode, exploring the implications of overriding methods and using context managers. Additionally, it provides examples of test-driven development for verifying the modified behavior.
What's new in Python 3.11
What's new in Python 3.11Henry Schreiner The document provides an overview of new features and improvements introduced in Python versions 3.6 to 3.11, highlighting enhancements in syntax, performance, and error handling. Key updates include structural pattern matching in Python 3.10, scheduled future plans for 3.12, and the introduction of exception groups for better error management. It also emphasizes packaging improvements and the transition towards a faster CPython with JIT plans.
Data types in python lecture (2)
Data types in python lecture (2)Ali ٍSattar This document provides an overview of data types in Python. It discusses the main data types including numeric, boolean, sequence, set and mapping types. Numeric types include int, float, long and complex. Sequence types include string, bytes, byte array, list and tuple. Sets are unordered collections that can contain different data types. Dictionaries are unordered collections of key-value pairs. The document also distinguishes between mutable objects like lists and dictionaries whose values can change, and immutable objects like integers, floats and tuples whose values cannot change.
Functional Programming inside OOP? It’s possible with Python
Functional Programming inside OOP? It’s possible with PythonCarlos V. The document discusses the integration of functional programming within object-oriented programming in Python, highlighting its benefits such as improved readability, easier debugging, and enhanced testing capabilities. It covers various topics including immutability, decorators, lazy evaluation, type annotations, and functional patterns like currying and composition. The author emphasizes how functional programming principles can streamline coding practices while citing Python's evolution and relevant features introduced over the years.
TID Chile dataviz
TID Chile datavizCarlos V. Este documento describe una infraestructura llamada agINFRA que tiene como objetivo promover la investigación científica en agricultura de forma libre exponiendo datos públicamente y utilizando recursos de computación en la nube. También describe una herramienta de visualización de redes sociales que forma parte de este proyecto, la cual permite visualizar las relaciones entre investigadores que trabajan en temas similares y navegar por estas conexiones basadas en información bibliográfica. Finalmente, proporciona detalles técnicos sobre las tecnologías utiliz
More Related Content
Similar to How to start using types in Python with mypy (20)
Python Tutorial
Python TutorialEueung Mulyana This document provides an overview of NumPy, the core library for scientific computing in Python. It discusses NumPy arrays, which provide a grid of values that are all of the same type and indexed by tuples of integers. NumPy arrays can be initialized from nested lists and accessed using square brackets. NumPy also provides functions to create arrays filled with zeros, ones, random values, or a constant. The document covers slicing NumPy arrays to extract subarrays, and integer array indexing to construct arbitrary arrays from another array's data. It demonstrates how slicing returns views into the original data, while integer indexing allows selecting elements in any order.
Python_Cheat_Sheet_Keywords_1664634397.pdf
Python_Cheat_Sheet_Keywords_1664634397.pdfsagar414433 This document provides a cheat sheet on Python keywords and basic data types. It lists common Python keywords like False, True, and, or, not, break, continue, class, def, if, else, for, while, in, is, None, lambda, and return along with code examples. It also covers basic data types like Boolean, integer, float, string, list, set, dictionary, and complex data types like classes. It provides examples of using lists, sets, dictionaries, classes and functions in Python.
Python_Cheat_Sheet_Keywords_1664634397.pdf
Python_Cheat_Sheet_Keywords_1664634397.pdfsagar414433 This document provides examples and descriptions of Python keywords and basic data types. It discusses keywords like False, True, and, or, not, break, continue, class, def, if, elif, else, for, while, in, is, None, lambda, and return. It also covers basic data types like integers, floats, strings, lists, sets, dictionaries, and Boolean values. It provides code examples to demonstrate the usage of these keywords and data types in Python.
FIot_Unit-3 fundAMENTALS OF IOT BASICS.pptx
FIot_Unit-3 fundAMENTALS OF IOT BASICS.pptxssuser0b643d This document is an introductory guide to Python programming covering installation, data types, control flow, functions, and data structures. It highlights Python's general-purpose nature, ease of learning, and broad library support. The document includes examples of basic operations and constructs in Python, making it suitable for beginners in programming.
Type hints in python & mypy
Type hints in python & mypyAnirudh This document discusses type hints in Python, including their purpose, implementation, and advantages such as improved code readability and early bug detection. It highlights the optional nature of type hints, which support gradual typing, and explains how various type checkers like mypy work alongside them. Additionally, it covers structural subtyping introduced by PEP 544 and provides examples and references related to the subject.
unit 1.docx
unit 1.docxssuser2e84e4 This document provides an overview of Python data types including numeric, string, sequence, mapping, boolean, and set data types. It describes the main classes for each data type such as int, float, complex for numeric types, str for strings, list, tuple, range for sequences, dict for mappings, bool for booleans, and set, frozenset for sets. It includes examples of defining variables of each data type and using functions like type() and isinstance() to check the data type. It also summarizes key aspects of each data type like how they can be indexed, sliced, concatenated, and repeated.
BUILDING IoT WITH ARDUINO & RASPBERRY PI
BUILDING IoT WITH ARDUINO & RASPBERRY PImanohar011101110 The document provides a comprehensive introduction to Python as a programming language, covering its basic features, data types, and system setup on different operating systems. It discusses various programming constructs including functions, control flow statements, and data structures such as lists, tuples, and dictionaries. Furthermore, it highlights Python's ease of use, extensibility, and broad library support, making it suitable for both beginner and advanced programming in cloud computing.
Tip Top Typing - A Look at Python Typing
Tip Top Typing - A Look at Python TypingPatrick Viafore The document discusses Python's typing system, highlighting the importance of types in conveying intent to developers and aiding in error detection. It covers topics such as primitive vs. composite types, user-defined types, type hinting, and generics, illustrating these concepts with examples. It emphasizes the role of types in both data representation and operational capabilities, along with the use of protocols and type restrictions.
User-Defined Types.pdf
User-Defined Types.pdfPatrick Viafore The document discusses the importance of creating a robust and maintainable codebase to facilitate collaboration among developers, focusing on user-defined types, data classes, and invariants. It emphasizes clear communication through code and the responsibilities of developers to minimize future errors and misunderstandings. The talk also explores software design principles, such as inheritance and the Liskov substitution principle, to enhance code quality and coherence.
Type Annotations in Python: Whats, Whys and Wows!
Type Annotations in Python: Whats, Whys and Wows!Andreas Dewes The document discusses type annotations in Python. It explains why type annotations are useful for finding bugs, provides a history of type hints in Python from PEP 3107 to PEP 544, and demonstrates three approaches to adding type hints: inline annotations, type comments, and stub files. It also analyzes real-world usage of type hints by checking over 100 popular Python projects on GitHub and discusses additional uses for annotations beyond type checking.
Domain Driven Design Made Functional with Python
Domain Driven Design Made Functional with Python Jean Carlo Machado This document discusses using domain modeling with types in Python using the static type checker Mypy. It motivates the use of types for domain-driven design and functional programming concepts. It then provides examples of building blocks for Mypy's type system algebra, including simple values with new types, combinations of values, modeling choices with unions, type functions, classes, generics, and putting the concepts together in a workflow. It also discusses limitations of Mypy and resources for further learning. The overall goal is to leave the reader inspired to learn more about applying type systems to domain modeling.
A tour of Python
A tour of PythonAleksandar Veselinovic The document provides a comprehensive overview of Python programming, detailing its syntax, data types, functions, classes, and modules. It covers essential programming concepts such as operators, expressions, control flow, and debugging techniques. Additionally, the document discusses advanced topics like context managers, decorators, and exception handling, along with practical examples and code snippets.
An overview of Python 2.7
An overview of Python 2.7decoupled This document provides an overview of the Python programming language. It covers topics such as syntax, types and objects, operators and expressions, functions, classes and object-oriented programming, modules and packages, input/output, and the Python execution environment. It also discusses generators and iterators versus regular functions, namespaces and scopes, and classes in Python.
Robust Python.pptx
Robust Python.pptxPatrick Viafore The document discusses how to write robust Python code that will be maintainable for future collaborators. It emphasizes communicating intent through deliberate choices in code abstractions like enums, data classes, classes, and inheritance. These choices should make it hard for developers to introduce errors and easy to understand the constraints of the system. The goal is to minimize future friction and enable collaborators to focus on delivering value rather than debugging issues.
2 + 2 = 5: Monkey-patching CPython with ctypes to conform to Party doctrine
2 + 2 = 5: Monkey-patching CPython with ctypes to conform to Party doctrineFrankie Dintino The document outlines methods for modifying Python's built-in integer addition behavior using ctypes and monkey patching, particularly to change the result of 2 + 2 to 5. It discusses challenges related to type errors and peephole optimization in Python's bytecode, exploring the implications of overriding methods and using context managers. Additionally, it provides examples of test-driven development for verifying the modified behavior.
What's new in Python 3.11
What's new in Python 3.11Henry Schreiner The document provides an overview of new features and improvements introduced in Python versions 3.6 to 3.11, highlighting enhancements in syntax, performance, and error handling. Key updates include structural pattern matching in Python 3.10, scheduled future plans for 3.12, and the introduction of exception groups for better error management. It also emphasizes packaging improvements and the transition towards a faster CPython with JIT plans.
Data types in python lecture (2)
Data types in python lecture (2)Ali ٍSattar This document provides an overview of data types in Python. It discusses the main data types including numeric, boolean, sequence, set and mapping types. Numeric types include int, float, long and complex. Sequence types include string, bytes, byte array, list and tuple. Sets are unordered collections that can contain different data types. Dictionaries are unordered collections of key-value pairs. The document also distinguishes between mutable objects like lists and dictionaries whose values can change, and immutable objects like integers, floats and tuples whose values cannot change.
More from Carlos V. (6)
Functional Programming inside OOP? It’s possible with Python
Functional Programming inside OOP? It’s possible with PythonCarlos V. The document discusses the integration of functional programming within object-oriented programming in Python, highlighting its benefits such as improved readability, easier debugging, and enhanced testing capabilities. It covers various topics including immutability, decorators, lazy evaluation, type annotations, and functional patterns like currying and composition. The author emphasizes how functional programming principles can streamline coding practices while citing Python's evolution and relevant features introduced over the years.
TID Chile dataviz
TID Chile datavizCarlos V. Este documento describe una infraestructura llamada agINFRA que tiene como objetivo promover la investigación científica en agricultura de forma libre exponiendo datos públicamente y utilizando recursos de computación en la nube. También describe una herramienta de visualización de redes sociales que forma parte de este proyecto, la cual permite visualizar las relaciones entre investigadores que trabajan en temas similares y navegar por estas conexiones basadas en información bibliográfica. Finalmente, proporciona detalles técnicos sobre las tecnologías utiliz
Open Data in Agriculture - AGH20013 Hands-on session
Open Data in Agriculture - AGH20013 Hands-on sessionCarlos V. The document discusses open data infrastructures for agriculture and presents an example end-user service built using components from agInfra. The service allows users to conduct faceted searches of agricultural data, filter results by predefined facets, and explore relationships between authors and publications in the data graph. It utilizes agInfra's GRID platform to access, harvest, and transform datasets into triples for scalable indexing and querying from the agInfra cloud.
APIVITA BeeNet - Athens Green Hackathon 2013
APIVITA BeeNet - Athens Green Hackathon 2013Carlos V. The document describes the Athens Green Hackathon held on December 14-15, 2013, focusing on developing an application for the Greek company Apivita, which produces natural health and beauty products. The proposed solution includes two modules: 'beetrained' for providing educational resources related to honey and herbs, and 'bee a supplier!' for screening potential suppliers. Both modules aim to streamline supplier negotiations and enhance user knowledge through multilingual capabilities and a connected knowledge base.
Findjira presentación
Findjira presentaciónCarlos V. Este documento describe el análisis, diseño e implementación de un marco de trabajo para la generación rápida de aplicaciones web multimedia interactivas. El marco recopila y unifica información de varios servicios web y formatos y ofrece una capa intermedia de desarrollo. Se analizan los casos de uso y actores, y se implementa el marco utilizando PHP, JSON y XML. Como prueba de concepto, se desarrolla una aplicación llamada Iguana Search que permite buscar y combinar información de diferentes fuentes.
agINFRA Workshop for LACLO2012
agINFRA Workshop for LACLO2012Carlos V. Este documento presenta la infraestructura agINFRA, un consorcio de 11 organizaciones que promueve el intercambio de información científica y tecnológica en agricultura a través de una infraestructura de datos y servicios interoperables. La arquitectura de agINFRA incluye subsistemas principales y una interfaz de programación de aplicaciones para permitir el acceso y compartir de datos entre comunidades científicas agrícolas.
Ad
Recently uploaded (20)
Techniques for Automatic Device Identification and Network Assignment.pdf
Techniques for Automatic Device Identification and Network Assignment.pdfPriyanka Aash Techniques for Automatic Device Identification and Network Assignment
Cracking the Code - Unveiling Synergies Between Open Source Security and AI.pdf
Cracking the Code - Unveiling Synergies Between Open Source Security and AI.pdfPriyanka Aash Cracking the Code - Unveiling Synergies Between Open Source Security and AI
"Scaling in space and time with Temporal", Andriy Lupa.pdf
"Scaling in space and time with Temporal", Andriy Lupa.pdfFwdays Design patterns like Event Sourcing and Event Streaming have long become standards for building real-time analytics systems. However, when the system load becomes nonlinear with fast and often unpredictable spikes, it's crucial to respond quickly in order not to lose real-time operating itself.
In this talk, I’ll share my experience implementing and using a tool like Temporal.io. We'll explore the evolution of our system for maintaining real-time report generation and discuss how we use Temporal both for short-lived pipelines and long-running background tasks.
Enhance GitHub Copilot using MCP - Enterprise version.pdf
Enhance GitHub Copilot using MCP - Enterprise version.pdfNilesh Gule Slide deck related to the GitHub Copilot Bootcamp in Melbourne on 17 June 2025
Curietech AI in action - Accelerate MuleSoft development
Curietech AI in action - Accelerate MuleSoft developmentshyamraj55 CurieTech AI in Action – Accelerate MuleSoft Development
Overview:
This presentation demonstrates how CurieTech AI’s purpose-built agents empower MuleSoft developers to create integration workflows faster, more accurately, and with less manual effort
linkedin.com
+12
curietech.ai
+12
meetups.mulesoft.com
+12
.
Key Highlights:
Dedicated AI agents for every stage: Coding, Testing (MUnit), Documentation, Code Review, and Migration
curietech.ai
+7
curietech.ai
+7
medium.com
+7
DataWeave automation: Generate mappings from tables or samples—95%+ complete within minutes
linkedin.com
+7
curietech.ai
+7
medium.com
+7
Integration flow generation: Auto-create Mule flows based on specifications—speeds up boilerplate development
curietech.ai
+1
medium.com
+1
Efficient code reviews: Gain intelligent feedback on flows, patterns, and error handling
youtube.com
+8
curietech.ai
+8
curietech.ai
+8
Test & documentation automation: Auto-generate MUnit test cases, sample data, and detailed docs from code
curietech.ai
+5
curietech.ai
+5
medium.com
+5
Why Now?
Achieve 10× productivity gains, slashing development time from hours to minutes
curietech.ai
+3
curietech.ai
+3
medium.com
+3
Maintain high accuracy with code quality matching or exceeding manual efforts
curietech.ai
+2
curietech.ai
+2
curietech.ai
+2
Ideal for developers, architects, and teams wanting to scale MuleSoft projects with AI efficiency
Conclusion:
CurieTech AI transforms MuleSoft development into an AI-accelerated workflow—letting you focus on innovation, not repetition.
EIS-Webinar-Engineering-Retail-Infrastructure-06-16-2025.pdf
EIS-Webinar-Engineering-Retail-Infrastructure-06-16-2025.pdfEarley Information Science As AI reshapes expectations in retail and B2B commerce, organizations are recognizing a critical reality: meaningful AI outcomes depend on well-structured, adaptable infrastructure. In this session, Seth Earley is joined by Phil Ryan - AI strategist, search technologist, and founder of Glass Leopard Technologies - for a candid conversation on what it truly means to engineer systems for scale, agility, and intelligence.
Phil draws on more than two decades of experience leading search and AI initiatives for enterprise organizations. Together, he and Seth explore the challenges businesses face when legacy architectures limit personalization, agility, and real-time decisioning - and what needs to change to support agentic technologies and next-best-action capabilities.
Key themes from the webinar include:
Composability as a prerequisite for AI - Why modular, loosely coupled systems are essential for adapting to rapid innovation and evolving business needs
Search and relevance as foundational to AI - How techniques honed-in enterprise search have laid the groundwork for more responsive and intelligent customer experiences
From MDM and CDP to agentic systems - How data platforms are evolving to support richer customer context and dynamic orchestration
Engineering for business alignment - Why successful AI programs require architectural decisions grounded in measurable outcomes
The conversation is practical and forward-looking, connecting deep technical understanding with real-world business needs. Whether you’re modernizing your commerce stack or exploring how AI can enhance product discovery, personalization, or customer journeys, this session provides a clear-eyed view of the capabilities, constraints, and priorities that matter most.
Security Tips for Enterprise Azure Solutions
Security Tips for Enterprise Azure SolutionsMichele Leroux Bustamante Delivering solutions to Azure may involve a variety of architecture patterns involving your applications, APIs data and associated Azure resources that comprise the solution. This session will use reference architectures to illustrate the security considerations to protect your Azure resources and data, how to achieve Zero Trust, and why it matters. Topics covered will include specific security recommendations for types Azure resources and related network security practices. The goal is to give you a breadth of understanding as to typical security requirements to meet compliance and security controls in an enterprise solution.
Smarter Aviation Data Management: Lessons from Swedavia Airports and Sweco
Smarter Aviation Data Management: Lessons from Swedavia Airports and SwecoSafe Software Managing airport and airspace data is no small task, especially when you’re expected to deliver it in AIXM format without spending a fortune on specialized tools. But what if there was a smarter, more affordable way?
Join us for a behind-the-scenes look at how Sweco partnered with Swedavia, the Swedish airport operator, to solve this challenge using FME and Esri.
Learn how they built automated workflows to manage periodic updates, merge airspace data, and support data extracts – all while meeting strict government reporting requirements to the Civil Aviation Administration of Sweden.
Even better? Swedavia built custom services and applications that use the FME Flow REST API to trigger jobs and retrieve results – streamlining tasks like securing the quality of new surveyor data, creating permdelta and baseline representations in the AIS schema, and generating AIXM extracts from their AIS data.
To conclude, FME expert Dean Hintz will walk through a GeoBorders reading workflow and highlight recent enhancements to FME’s AIXM (Aeronautical Information Exchange Model) processing and interpretation capabilities.
Discover how airports like Swedavia are harnessing the power of FME to simplify aviation data management, and how you can too.
GenAI Opportunities and Challenges - Where 370 Enterprises Are Focusing Now.pdf
GenAI Opportunities and Challenges - Where 370 Enterprises Are Focusing Now.pdfPriyanka Aash GenAI Opportunities and Challenges - Where 370 Enterprises Are Focusing Now
OpenACC and Open Hackathons Monthly Highlights June 2025
OpenACC and Open Hackathons Monthly Highlights June 2025OpenACC The OpenACC organization focuses on enhancing parallel computing skills and advancing interoperability in scientific applications through hackathons and training. The upcoming 2025 Open Accelerated Computing Summit (OACS) aims to explore the convergence of AI and HPC in scientific computing and foster knowledge sharing. This year's OACS welcomes talk submissions from a variety of topics, from Using Standard Language Parallelism to Computer Vision Applications. The document also highlights several open hackathons, a call to apply for NVIDIA Academic Grant Program and resources for optimizing scientific applications using OpenACC directives.
Oh, the Possibilities - Balancing Innovation and Risk with Generative AI.pdf
Oh, the Possibilities - Balancing Innovation and Risk with Generative AI.pdfPriyanka Aash Oh, the Possibilities - Balancing Innovation and Risk with Generative AI
AI vs Human Writing: Can You Tell the Difference?
AI vs Human Writing: Can You Tell the Difference?Shashi Sathyanarayana, Ph.D This slide illustrates a side-by-side comparison between human-written, AI-written, and ambiguous content. It highlights subtle cues that help readers assess authenticity, raising essential questions about the future of communication, trust, and thought leadership in the age of generative AI.
Tech-ASan: Two-stage check for Address Sanitizer - Yixuan Cao.pdf
Tech-ASan: Two-stage check for Address Sanitizer - Yixuan Cao.pdfcaoyixuan2019 A presentation at Internetware 2025.
Agentic AI for Developers and Data Scientists Build an AI Agent in 10 Lines o...
Agentic AI for Developers and Data Scientists Build an AI Agent in 10 Lines o...All Things Open Presented at All Things Open RTP Meetup
Presented by William Hill - Developer Advocate, NVIDIA
Title: Agentic AI for Developers and Data Scientists
Build an AI Agent in 10 Lines of Code and the Concepts Behind the Code
Abstract: In this talk we will demonstrate building a working data science AI agent in 10 lines of basic Python code in a Colab notebook. Our AI Agent will perform LLM prompt-driven visual analysis using open-source libraries. In this session we will show how to develop an AI Agent using GPUs through NVIDIA’s developer program and Google Colab notebooks. After coding our AI Agent, we will break down the 10 lines of code. We will show the key components and open source library integrations that enable the agent's functionality, focusing on practical implementation details and then the theoretical concepts. The presentation concludes with a survey of current LLM technologies and the latest trends in developing AI applications for enthusiasts and enterprises
Quantum AI: Where Impossible Becomes Probable
Quantum AI: Where Impossible Becomes ProbableSaikat Basu Imagine combining the "brains" of Artificial Intelligence (AI) with the "super muscles" of Quantum Computing. That's Quantum AI!
It's a new field that uses the mind-bending rules of quantum physics to make AI even more powerful.
Quantum AI Discoveries: Fractal Patterns Consciousness and Cyclical Universes
Quantum AI Discoveries: Fractal Patterns Consciousness and Cyclical UniversesSaikat Basu Embark on a cosmic journey exploring the intersection of quantum
computing, consciousness, and ancient wisdom. Together we'll uncover the
recursive patterns that bind our reality.
Lessons Learned from Developing Secure AI Workflows.pdf
Lessons Learned from Developing Secure AI Workflows.pdfPriyanka Aash Lessons Learned from Developing Secure AI Workflows
Using the SQLExecutor for Data Quality Management: aka One man's love for the...
Using the SQLExecutor for Data Quality Management: aka One man's love for the...Safe Software The SQLExecutor is one of FME’s most powerful and flexible transformers. Pivvot maintains a robust internal metadata hierarchy used to support ingestion and curation of thousands of external data sources that must be managed for quality before entering our platform. By using the SQLExecutor, Pivvot can efficiently detect problems and perform analysis before data is extracted from our staging environment, removing the need for rollbacks or cycles waisted on a failed job. This presentation will walk through three distinct examples of how Pivvot uses the SQLExecutor to engage its metadata hierarchy and integrate with its Data Quality Management workflows efficiently and within the source postgres database. Spatial Validation –Validating spatial prerequisites before entering a production environment. Reference Data Validation - Dynamically validate domain-ed columns across any table and multiple columns per table. Practical De-duplication - Removing identical or near-identical well point locations from two distinct source datasets in the same table.
Ad
How to start using types in Python with mypy
- 1. How to start using types in Python with Mypy
- 2. Carlos Villavicencio Ecuadorian Software Developer at Stack Builders Community leader Amateur photographer cvillavicencio [email protected] @po5i po5i Quilotoa Lake, Ecuador 2020. 大家好!
- 4. Data Structures Primitive Non-primitive Integer Float String Boolean Array List Tuple Dictionary Set File Linear Non-linear Stacks Queues Graphs Trees
- 7. Types are known in compilation time Variables bind to types Very verbose Bytecode is well optimized in memory Types are known in runtime Variables bind to objects 🦆 Less verbose Bugs in run-time are very common Dynamic vs. Static Languages
- 8. Weakly vs. Strongly Type System Implicit coercion between non-related types Flexibles Unpredictables Explicit type conversion (casting) Strict rules on the static analysis. Type Safety
- 9. Static type checking in Python But you can also use
- 10. Type Annotations
- 11. meat: str = "Beef" weight_pounds: float = "0.5" # mypy # error: Incompatible types in assignment # (expression has type "str", variable has type "float") Primitive types 🦕
- 12. Let’s prepare some 🍔 def make_hamburger(meat, number_of_meats): return ["bread"] + [meat] * number_of_meats + ["bread"] print(make_hamburger("BEEF", 2)) # ['bread', 'BEEF', 'BEEF', 'bread']
- 13. class MyTest(unittest.TestCase): def test_make_hamburger_returns_list(self): self.assertTrue(isinstance(make_hamburger("beef", 2), list)) def test_empty_make_hamburger_returns_breads(self): self.assertEqual(make_hamburger(None, 0), ['bread', 'bread']) def test_invalid_make_hamburger_raises(self): with self.assertRaises(TypeError): make_hamburger() Unit testing?
- 14. from typing import List def make_hamburger(meat: str, number_of_meats: int) -> List[str]: return ["bread"] + [meat] * number_of_meats + ["bread"] The `typing`module
- 15. from typing import List Hamburger = List[str] def make_hamburger(meat: str, number_of_meats: int) -> Hamburger: return ["bread"] + [meat] * number_of_meats + ["bread"] Type Alias
- 16. from typing import List, Optional Hamburger = List[str] Extras = Optional[List[str]] def make_hamburger(meat: str, number_of_meats: int, extras: Extras) -> Hamburger: if extras: return ["bread"] + extras + [meat] * number_of_meats + ["bread"] else: return ["bread"] + [meat] * number_of_meats + ["bread"] print(make_hamburger("Beef", 2, ['tomatoes', 'pickles'])) # ['bread', 'tomatoes', 'pickles', 'Beef', 'Beef', 'bread'] Optionals 🍅
- 17. from typing import TypeVar, List T = TypeVar("T", int, List[str]) def generic_add(x: T, y: T) -> T: return x + y Generics
- 18. x1: int = 5 y1: int = 2 print(generic_add(x1, y1)) # 7 x2: List[str] = ["Hello"] y2: List[str] = ["World"] print(generic_add(x2, y2)) # ['Hello', 'World'] x3: str = "foo" y3: str = "bar" print(generic_add(x3, y3)) # mypy error: Value of type variable "T" of "generic_add" cannot be "str" Generics
- 19. from typing import Union Number = Union[float, int] def union_add(x: Number, y: Number) -> Number: return x + y Union Types
- 20. x1: int = 5 y1: float = 2.5 print(union_add(x1, y1)) # 7 x2: int = 2 y2: str = "1" print(union_add(x2, y2)) # error: Argument 1 to "union_add" has incompatible type "str"; expected "Union[float, int]" # error: Argument 2 to "union_add" has incompatible type "str"; expected "Union[float, int]" Union Types
- 21. from typing import Callable def sum_and_process(a: int, b: int, callback: Callable[[int], bool]) -> bool: total = a + b return callback(total) def is_positive(val: int) -> bool: return val > 0 output = sum_and_process(5, 2, is_positive) print(output) # True Callables
- 23. 谢谢! ευχαριστώ Obrigado! ¡Gracias! Thank You! Check out my tutorial